static char *hyphen(char *dst, const char *src, char delim) { const char *exp = expchck(src, delim); if (exp) return strcpy(dst, exp); char txt[TOKLEN + 1]; sprintf(txt, ".%s.", src); char *txtend = txt + strlen(txt); uint8_t wght[TOKLEN + 1] = {0}; for (char *s = txt; *s; ++s) { char *p = s; trie_t trie = pattern; while (p <= txtend && trie) { if (trie_child(trie, 0)) for (char *i = s; i <= p; ++i) wght[i - txt] = MAX( wght[i - txt], ((uint8_t *)trie_find(trie, ""))[i - s] ); trie = trie_child(trie, tolower(*p++)); } } wght[1] = wght[2] = 0; wght[txtend - txt - 1] = wght[txtend - txt - 2] = 0; char *pdst = dst; for (char *s = txt + 1; s < txtend - 1; *pdst++ = *s++) if (wght[s - txt] & 1) *pdst++ = delim; *pdst = 0; return dst; }
static void update_common_dir(struct strbuf *buf, int git_dir_len, const char *common_dir) { char *base = buf->buf + git_dir_len; init_common_trie(); if (trie_find(&common_trie, base, check_common, NULL) > 0) replace_dir(buf, git_dir_len, common_dir); }
bool trie_remove(trie_t trie, const char * word, void ** data) { int len = strlen(word); bool dataflag = true; trie_t temp = trie; if (!trie_find(trie, word)) return false; //move to the end of work pos for (int i = 0; i < len; i++) { temp = temp->next[ (word[i]) - ' ']; } if (temp->endNode != true) { if (!temp->nodePtr->value) return false; if (data !=NULL) *data = temp->nodePtr->value; temp->nodePtr->value=NULL; return true; } if (temp->endNode == true) { trie_t temp2; for (int i = len-1; i >= 0; i--) { temp2 = temp->pre; if (data != NULL&&dataflag) { *data = temp->nodePtr->value; dataflag = false; } trie_destroy(temp, NULL); temp2->next[ (word[i]) - ' '] = NULL; for (int i = 0; i < SUBTREEPOSSIBLENUM; i++) { if (temp2->next[i] != NULL) return true; } temp = temp2; if (temp->nodePtr->value) { temp->endNode = true; return true; } } } return true; }
int parse_and_print_to_stdout(const char * operation) { if (NULL == operation) { skip_line(stdin); return -1; } if (0 == strcmp(OP_INSERT, operation)) { if (0 != parse_insert(stdin, word_buffer, MAX_WORD_LEN)) return -1; int word_num = trie_insert(word_buffer); if (word_num < 0) return -1; printf("word number: %d\n", word_num); } if (0 == strcmp(OP_PREV, operation)) { int number, start, end; if (0 != parse_prev(stdin, &number, &start, &end)) return -1; int word_num = trie_prev(number, start, end); if (word_num < 0) return -1; printf("word number: %d\n", word_num); } if (0 == strcmp(OP_DELETE, operation)) { int number; if (0 != parse_delete(stdin, &number)) return -1; int word_num = trie_delete(number); if (word_num < 0) return -1; printf("deleted: %d\n", number); } if (0 == strcmp(OP_FIND, operation)) { if (0 != parse_find(stdin, word_buffer, MAX_WORD_LEN)) return -1; int find_result = trie_find(word_buffer, strlen(word_buffer)); if (find_result < 0) return -1; puts(find_result == 0 ? "YES" : "NO"); } if (0 == strcmp(OP_CLEAR, operation)) { if (0 != parse_clear(stdin)) return -1; if (0 != trie_clear()) return -1; puts("cleared"); } return 0; }
falcon_object_t *falcon_cache_get(falcon_cache_t *cache, const gchar *name) { trie_node_t *node = NULL; g_return_val_if_fail(cache, NULL); g_return_val_if_fail(name, NULL); g_mutex_lock(cache->lock); node = trie_find(cache->objects, name); g_mutex_unlock(cache->lock); return trie_data(node); }
/* * Search a trie for some key. Find the longest /-or-\0-terminated * prefix of the key for which the trie contains a value. Call fn * with the unmatched portion of the key and the found value, and * return its return value. If there is no such prefix, return -1. * * The key is partially normalized: consecutive slashes are skipped. * * For example, consider the trie containing only [refs, * refs/worktree] (both with values). * * | key | unmatched | val from node | return value | * |-----------------|------------|---------------|--------------| * | a | not called | n/a | -1 | * | refs | \0 | refs | as per fn | * | refs/ | / | refs | as per fn | * | refs/w | /w | refs | as per fn | * | refs/worktree | \0 | refs/worktree | as per fn | * | refs/worktree/ | / | refs/worktree | as per fn | * | refs/worktree/a | /a | refs/worktree | as per fn | * |-----------------|------------|---------------|--------------| * */ static int trie_find(struct trie *root, const char *key, match_fn fn, void *baton) { int i; int result; struct trie *child; if (!*key) { /* we have reached the end of the key */ if (root->value && !root->len) return fn(key, root->value, baton); else return -1; } for (i = 0; i < root->len; i++) { /* Partial path normalization: skip consecutive slashes. */ if (key[i] == '/' && key[i+1] == '/') { key++; continue; } if (root->contents[i] != key[i]) return -1; } /* Matched the entire compressed section */ key += i; if (!*key) /* End of key */ return fn(key, root->value, baton); /* Partial path normalization: skip consecutive slashes */ while (key[0] == '/' && key[1] == '/') key++; child = root->children[(unsigned char)*key]; if (child) result = trie_find(child, key + 1, fn, baton); else result = -1; if (result >= 0 || (*key != '/' && *key != 0)) return result; if (root->value) return fn(key, root->value, baton); else return -1; }
void falcon_cache_foreach_descendant(falcon_cache_t *cache, const gchar *name, GFunc func, gpointer userdata) { trie_node_t *node = NULL; falcon_object_t *data = NULL; g_return_if_fail(cache); g_return_if_fail(func); g_mutex_lock(cache->lock); node = trie_find(cache->objects, name); falcon_cache_recursive_foreach_descendant(trie_child(node), func, userdata); if ((data = trie_data(node))) func(data, userdata); g_mutex_unlock(cache->lock); }
static int automaton_contains(PyObject* self, PyObject* args) { #define automaton ((Automaton*)self) ssize_t wordlen; TRIE_LETTER_TYPE* word; PyObject* py_word; py_word = pymod_get_string(args, &word, &wordlen); if (py_word == NULL) return -1; TrieNode* node = trie_find(automaton->root, word, wordlen); Py_DECREF(py_word); return (node and node->eow); #undef automaton }
bool trie_find(Trie * node, char *tema) { assert(tema != NULL && *tema != '\0' && node != NULL && POS(tema) >= 0); //apenas procurar se o proximo char nao for o fim da palavra if(*(tema+1) != '\0' && node->table[POS(tema)] != NULL) { return trie_find(node->table[POS(tema)], tema+1); } //e a ultima letra da palavra, verificar se esta marcado como uma palavra. else if( node->table[POS(tema)] != NULL && node->table[POS(tema)]->word == 1 ) { return true; } //nao encontrou return false; }
static PyObject* automaton_get(PyObject* self, PyObject* args) { #define automaton ((Automaton*)self) ssize_t wordlen; TRIE_LETTER_TYPE* word; PyObject* py_word; PyObject* py_def; py_word = pymod_get_string_from_tuple(args, 0, &word, &wordlen); if (py_word == NULL) return NULL; TrieNode* node = trie_find(automaton->root, word, wordlen); if (node and node->eow) { switch (automaton->store) { case STORE_INTS: case STORE_LENGTH: return Py_BuildValue("i", node->output.integer); case STORE_ANY: Py_INCREF(node->output.object); return node->output.object; default: PyErr_SetNone(PyExc_ValueError); return NULL; } } else { py_def = PyTuple_GetItem(args, 1); if (py_def) { Py_INCREF(py_def); return py_def; } else { PyErr_Clear(); PyErr_SetNone(PyExc_KeyError); return NULL; } } #undef automaton }
static PyObject* automaton_match(PyObject* self, PyObject* args) { #define automaton ((Automaton*)self) ssize_t wordlen; TRIE_LETTER_TYPE* word; PyObject* py_word; py_word = pymod_get_string_from_tuple(args, 0, &word, &wordlen); if (py_word == NULL) return NULL; TrieNode* node = trie_find(automaton->root, word, wordlen);; Py_DECREF(py_word); if (node) Py_RETURN_TRUE; else Py_RETURN_FALSE; #undef automaton }
void falcon_cache_foreach_child(falcon_cache_t *cache, const gchar *name, GFunc func, gpointer userdata) { trie_node_t *node = NULL; trie_node_t *next = NULL; falcon_object_t *data = NULL; g_return_if_fail(cache); g_return_if_fail(func); g_mutex_lock(cache->lock); node = trie_find(cache->objects, name); next = trie_child(node); while (next) { if ((data = trie_data(next))) func(data, userdata); next = trie_next(next); } if ((data = trie_data(node))) func(data, userdata); g_mutex_unlock(cache->lock); }
gboolean falcon_cache_delete(falcon_cache_t *cache, const gchar *name) { trie_node_t *node = NULL; g_return_val_if_fail(cache, FALSE); g_return_val_if_fail(name, FALSE); g_mutex_lock(cache->lock); node = trie_find(cache->objects, name); if (!node) { g_mutex_unlock(cache->lock); g_warning(_("Failed to delete \"%s\", it does not exist in the cache."), name); return FALSE; } trie_delete(cache->objects, name, (trie_free_func)falcon_object_free); cache->count--; g_mutex_unlock(cache->lock); return TRUE; }
gboolean falcon_cache_add(falcon_cache_t *cache, falcon_object_t *object) { trie_node_t *old_node = NULL; falcon_object_t *old = NULL; falcon_object_t *dup = falcon_object_copy(object); g_return_val_if_fail(cache, FALSE); g_return_val_if_fail(object, FALSE); g_mutex_lock(cache->lock); old_node = trie_find(cache->objects, falcon_object_get_name(dup)); if (old_node && (old = trie_data(old_node))) { falcon_object_free(old); trie_set_data(old_node, dup); } else { trie_add(cache->objects, falcon_object_get_name(dup), dup); cache->count++; } g_mutex_unlock(cache->lock); return TRUE; }
bool dictionary_find(const struct dictionary *dict, const wchar_t* word) { return trie_find(dict->tree, word); }