void match(void) { static char **tokv = NULL; static int tokn = 0; char buf[sizeof text], *s; int i, tokc = 0; size_t len; Item *item, *lprefix, *lsubstr, *prefixend, *substrend; strcpy(buf, text); /* separate input text into tokens to be matched individually */ for(s = strtok(buf, " "); s; tokv[tokc-1] = s, s = strtok(NULL, " ")) if(++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv))) die("cannot realloc %u bytes\n", tokn * sizeof *tokv); if (tokc && unitary) { strcpy(buf, text); tokc = 1; tokv[0] = buf; } len = tokc ? strlen(tokv[0]) : 0; matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL; for(item = items; item && item->text; item++) { for(i = 0; i < tokc; i++) if(!fstrstr(item->text, tokv[i])) break; if(i != tokc) /* not all tokens match */ continue; /* exact matches go first, then prefixes, then substrings */ if(!tokc || !fstrncmp(tokv[0], item->text, len+1)) { if (tokc || !item->hidden) appenditem(item, &matches, &matchend); } else if(!fstrncmp(tokv[0], item->text, len)) appenditem(item, &lprefix, &prefixend); else appenditem(item, &lsubstr, &substrend); } if(lprefix) { if(matches) { matchend->right = lprefix; lprefix->left = matchend; } else matches = lprefix; matchend = prefixend; } if(lsubstr) { if(matches) { matchend->right = lsubstr; lsubstr->left = matchend; } else matches = lsubstr; matchend = substrend; } curr = sel = matches; calcoffsets(); }
Bool setcommonpref(Bool again) { size_t len, t, start, maxlen; int c; Item *item, *prefitem; if (!curr || text[0] == 0) { return False; } /* Find an item that is a suffix of the current text, and the minimum length of all items that are suffixes of the current text. */ maxlen = sizeof(text); prefitem = NULL; start = strlen(text); for (item = curr; item != next; item = item->right) { if (fstrncmp(item->text, text, start) != 0) continue; if (!prefitem) prefitem = item; t = strlen(item->text); if (maxlen > t) maxlen = t; break; } if (!prefitem) return False; /* Repeatedly attempt to lengthen the common prefix. */ for (len = start; len < maxlen; len++) { c = prefitem->text[len]; for (item = curr; item != next; item = item->right) { if (fstrncmp(item->text, text, start) != 0) continue; if (item->text[len] != c) { if (len == start) return again; else { strncpy(text, item->text, len); text[len] = 0; } return True; } } } strncpy(text, prefitem->text, len+1); return True; }
static char* fstrstr(const char *s, const char *sub) { for (size_t len = strlen(sub); *s; s++) if (!fstrncmp(s, sub, len)) return (char*)s; return NULL; }
void match(void) { size_t len; Item *item, *itemend, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend; len = strlen(text); matches = lexact = lprefix = lsubstr = itemend = exactend = prefixend = substrend = NULL; for(item = items; item; item = item->next) if(!fstrncmp(text, item->text, len + 1)) { appenditem(item, &lexact, &exactend); } else if(!fstrncmp(text, item->text, len)) { appenditem(item, &lprefix, &prefixend); } else if(fstrstr(item->text, text)) { appenditem(item, &lsubstr, &substrend); } if(lexact) { matches = lexact; itemend = exactend; } if(lprefix) { if(itemend) { itemend->right = lprefix; lprefix->left = itemend; } else matches = lprefix; itemend = prefixend; } if(lsubstr) { if(itemend) { itemend->right = lsubstr; lsubstr->left = itemend; } else matches = lsubstr; } curr = prev = next = sel = matches; calcoffsets(); if(returnearly && !curr->right) { handle_return(curr->text); } }
/* Precondition: f needs to be pointing to the start of the central * directory. If you know you haven't reached path yet, you're still * OK as long as f is pointing to the start of a central directory * record.*/ static int find_file_in_zip(FILE *f, const char *path, struct zip_entry *ze) { while (1) { short fnameLen; int magic, suffixLen; long offset; magic = loadInt(f); if (magic == 0x06054b50 || magic == 0x05054b50 || magic == 0x06064b50) { /* We've hit the End of Central Directory record, a * digital signature block, or a Zip64 end of directory * record. We're done, and we didn't find what we were * looking for. */ return 0; } if (magic != 0x02014b50) { /* ZIP directory corrupt */ return 0; } loadSkip(f, 6); ze->compression = loadShort(f); loadSkip(f, 4); ze->crc32 = loadInt(f); ze->compressedSize = loadInt(f); ze->uncompressedSize = loadInt(f); fnameLen = loadShort(f); suffixLen = loadShort(f); suffixLen += loadShort(f); loadSkip(f, 8); offset = loadInt(f); if (!fstrncmp(f, fnameLen, path)) { if (ze->compression != 0 && ze->compression != 8) { /* Unknown compression type */ return 0; } fseek(f, offset, SEEK_SET); suffixLen = 0; magic = loadInt(f); if (magic != 0x04034b50) { /* ZIP directory corrupt */ return 0; } loadSkip(f, 22); suffixLen += loadShort(f); suffixLen += loadShort(f); loadSkip(f, suffixLen); return 1; } /* That wasn't it. Skip the suffix to get to the next * entry */ loadSkip(f, suffixLen); } /* This should really qualify as unreachable code */ return 0; }
void match(int sub) { size_t len = strlen(text); Item *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend; Item *item, *lnext; lexact = lprefix = lsubstr = exactend = prefixend = substrend = NULL; for(item = sub ? matches : items; item && item->text; item = lnext) { lnext = sub ? item->right : item + 1; if(!fstrncmp(text, item->text, len + 1)) appenditem(item, &lexact, &exactend); else if(!fstrncmp(text, item->text, len)) appenditem(item, &lprefix, &prefixend); else if(fstrstr(item->text, text)) appenditem(item, &lsubstr, &substrend); } matches = lexact; matchend = exactend; if(lprefix) { if(matchend) { matchend->right = lprefix; lprefix->left = matchend; } else matches = lprefix; matchend = prefixend; } if(lsubstr) { if(matchend) { matchend->right = lsubstr; lsubstr->left = matchend; } else matches = lsubstr; matchend = substrend; } curr = sel = matches; calcoffsets(); }
static void grabkeyboard(void) { struct timespec ts = { .tv_sec = 0, .tv_nsec = 1000000 }; int i; /* try to grab keyboard, we may have to wait for another process to ungrab */ for (i = 0; i < 1000; i++) { if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) return; nanosleep(&ts, NULL); } die("cannot grab keyboard\n"); } static void match(void) { static char **tokv = NULL; static int tokn = 0; char buf[sizeof text], *s; int i, tokc = 0; size_t len, textsize; struct item *item, *lprefix, *lsubstr, *prefixend, *substrend; strcpy(buf, text); /* separate input text into tokens to be matched individually */ for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " ")) if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv))) die("cannot realloc %u bytes\n", tokn * sizeof *tokv); len = tokc ? strlen(tokv[0]) : 0; matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL; textsize = strlen(text); for (item = items; item && item->text; item++) { for (i = 0; i < tokc; i++) if (!fstrstr(item->text, tokv[i])) break; if (i != tokc) /* not all tokens match */ continue; /* exact matches go first, then prefixes, then substrings */ if (!tokc || !fstrncmp(text, item->text, textsize)) appenditem(item, &matches, &matchend); else if (!fstrncmp(tokv[0], item->text, len)) appenditem(item, &lprefix, &prefixend); else appenditem(item, &lsubstr, &substrend); } if (lprefix) { if (matches) { matchend->right = lprefix; lprefix->left = matchend; } else matches = lprefix; matchend = prefixend; } if (lsubstr) { if (matches) { matchend->right = lsubstr; lsubstr->left = matchend; } else matches = lsubstr; matchend = substrend; } curr = sel = matches; calcoffsets(); } static void insert(const char *str, ssize_t n) { if (strlen(text) + n > sizeof text - 1) return; /* move existing text out of the way, insert new text, and update cursor */ memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0)); if (n > 0) memcpy(&text[cursor], str, n); cursor += n; match(); } static size_t nextrune(int inc) { ssize_t n; /* return location of next utf8 rune in the given direction (+1 or -1) */ for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc) ; return n; }
static void grabkeyboard(void) { struct timespec ts = { .tv_sec = 0, .tv_nsec = 1000000 }; int i; /* try to grab keyboard, we may have to wait for another process to ungrab */ for (i = 0; i < 1000; i++) { if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) return; nanosleep(&ts, NULL); } die("cannot grab keyboard\n"); } static void match(void) { static char **tokv = NULL; static int tokn = 0; char buf[sizeof text], *s; int i, tokc = 0; size_t len, textsize; struct item *item, *lprefix, *lsubstr, *prefixend, *substrend; strcpy(buf, text); /* separate input text into tokens to be matched individually */ for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " ")) if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv))) die("cannot realloc %u bytes\n", tokn * sizeof *tokv); len = tokc ? strlen(tokv[0]) : 0; matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL; textsize = strlen(text); for (item = items; item && item->text; item++) { for (i = 0; i < tokc; i++) if (!fstrstr(item->text, tokv[i])) break; if (i != tokc) /* not all tokens match */ continue; /* exact matches go first, then prefixes, then substrings */ if (!tokc || !fstrncmp(text, item->text, textsize)) appenditem(item, &matches, &matchend); else if (!fstrncmp(tokv[0], item->text, len)) appenditem(item, &lprefix, &prefixend); else appenditem(item, &lsubstr, &substrend); } if (lprefix) { if (matches) { matchend->right = lprefix; lprefix->left = matchend; } else matches = lprefix; matchend = prefixend; } if (lsubstr) { if (matches) { matchend->right = lsubstr; lsubstr->left = matchend; } else matches = lsubstr; matchend = substrend; } curr = sel = matches; calcoffsets(); } int compare_distance(const void *a, const void *b) { struct item *da = *(struct item **) a; struct item *db = *(struct item **) b; if (!db) return 1; if (!da) return -1; return da->distance - db->distance; } void fuzzymatch(void) { /* bang - we have so much memory */ struct item *it; struct item **fuzzymatches = NULL; char c; int number_of_matches = 0, i, pidx, sidx, eidx; int text_len = strlen(text), itext_len; matches = matchend = NULL; if (!isFuzzyMatch) { match(); return; } /* walk through all items */ for (it = items; it && it->text; it++) { if (text_len) { itext_len = strlen(it->text); pidx = 0; sidx = eidx = -1; /* walk through item text */ for (i = 0; i < itext_len && (c = it->text[i]); i++) { /* fuzzy match pattern */ if (text[pidx] == c) { if(sidx == -1) sidx = i; pidx++; if (pidx == text_len) { eidx = i; break; } } } /* build list of matches */ if (eidx != -1) { /* compute distance */ /* factor in 30% of sidx and distance between eidx and total * text length .. let's see how it works */ it->distance = eidx - sidx + (itext_len - eidx + sidx) / 3; appenditem(it, &matches, &matchend); number_of_matches++; } } else { appenditem(it, &matches, &matchend); } } if (number_of_matches) { /* initialize array with matches */ if (!(fuzzymatches = realloc(fuzzymatches, number_of_matches * sizeof(struct item*)))) die("cannot realloc %u bytes:", number_of_matches * sizeof(struct item*)); for (i = 0, it = matches; it && i < number_of_matches; i++, it = it->right) { fuzzymatches[i] = it; } /* sort matches according to distance */ qsort(fuzzymatches, number_of_matches, sizeof(struct item*), compare_distance); /* rebuild list of matches */ matches = matchend = NULL; for (i = 0, it = fuzzymatches[i]; i < number_of_matches && it && \ it->text; i++, it = fuzzymatches[i]) { appenditem(it, &matches, &matchend); } free(fuzzymatches); } curr = sel = matches; calcoffsets(); } static void insert(const char *str, ssize_t n) { if (strlen(text) + n > sizeof text - 1) return; /* move existing text out of the way, insert new text, and update cursor */ memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0)); if (n > 0) memcpy(&text[cursor], str, n); cursor += n; fuzzymatch(); } static size_t nextrune(int inc) { ssize_t n; /* return location of next utf8 rune in the given direction (+1 or -1) */ for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc) ; return n; }
static void grabfocus(void) { struct timespec ts = { .tv_sec = 0, .tv_nsec = 10000000 }; Window focuswin; int i, revertwin; for (i = 0; i < 100; ++i) { XGetInputFocus(dpy, &focuswin, &revertwin); if (focuswin == win) return; XSetInputFocus(dpy, win, RevertToParent, CurrentTime); nanosleep(&ts, NULL); } die("cannot grab focus"); } static void grabkeyboard(void) { struct timespec ts = { .tv_sec = 0, .tv_nsec = 1000000 }; int i; if (embed) return; /* try to grab keyboard, we may have to wait for another process to ungrab */ for (i = 0; i < 1000; i++) { if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) return; nanosleep(&ts, NULL); } die("cannot grab keyboard"); } static void match(void) { static char **tokv = NULL; static int tokn = 0; char buf[sizeof text], *s; int i, tokc = 0; size_t len, textsize; struct item *item, *lprefix, *lsubstr, *prefixend, *substrend; strcpy(buf, text); /* separate input text into tokens to be matched individually */ for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " ")) if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv))) die("cannot realloc %u bytes:", tokn * sizeof *tokv); len = tokc ? strlen(tokv[0]) : 0; matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL; textsize = strlen(text); for (item = items; item && item->text; item++) { for (i = 0; i < tokc; i++) if (!fstrstr(item->text, tokv[i])) break; if (i != tokc) /* not all tokens match */ continue; /* exact matches go first, then prefixes, then substrings */ if (!tokc || !fstrncmp(text, item->text, textsize)) appenditem(item, &matches, &matchend); else if (!fstrncmp(tokv[0], item->text, len)) appenditem(item, &lprefix, &prefixend); else appenditem(item, &lsubstr, &substrend); } if (lprefix) { if (matches) { matchend->right = lprefix; lprefix->left = matchend; } else matches = lprefix; matchend = prefixend; } if (lsubstr) { if (matches) { matchend->right = lsubstr; lsubstr->left = matchend; } else matches = lsubstr; matchend = substrend; } curr = sel = matches; calcoffsets(); } static void insert(const char *str, ssize_t n) { if (strlen(text) + n > sizeof text - 1) return; /* move existing text out of the way, insert new text, and update cursor */ memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0)); if (n > 0) memcpy(&text[cursor], str, n); cursor += n; match(); } static size_t nextrune(int inc) { ssize_t n; /* return location of next utf8 rune in the given direction (+1 or -1) */ for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc) ; return n; } static void loadhistory(void) { FILE *fp = NULL; size_t sz; if (!histfile) return; if (!(fp = fopen(histfile, "r"))) return; fseek(fp, 0, SEEK_END); sz = ftell(fp); fseek(fp, 0, SEEK_SET); if (sz) { histsz = sz + 1 + BUFSIZ; if (!(histbuf = malloc(histsz))) { fprintf(stderr, "warning: cannot malloc %lu "\ "bytes", histsz); } else { histptr = histbuf + fread(histbuf, 1, sz, fp); if (histptr <= histbuf) { /* fread error */ free(histbuf); histbuf = NULL; return; } if (histptr[-1] != '\n') *histptr++ = '\n'; histptr[BUFSIZ - 1] = '\0'; *histptr = '\0'; histsz = histptr - histbuf + BUFSIZ; } } fclose(fp); }