From dbe4f4274d5a46fcdbb5e9c0076f9bf21bb56094 Mon Sep 17 00:00:00 2001 From: Alexander Bocken Date: Thu, 30 Apr 2020 05:22:53 +0200 Subject: [PATCH] added patch to run if only one option is left --- LICENSE | 30 +++ dmenu.c | 780 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ dmenu.o | Bin 0 -> 33040 bytes drw.o | Bin 0 -> 10472 bytes stest.1 | 90 +++++++ stest.c | 109 ++++++++ stest.o | Bin 0 -> 5296 bytes util.c | 35 +++ util.o | Bin 0 -> 2224 bytes 9 files changed, 1044 insertions(+) create mode 100644 LICENSE create mode 100644 dmenu.c create mode 100644 dmenu.o create mode 100644 drw.o create mode 100644 stest.1 create mode 100644 stest.c create mode 100644 stest.o create mode 100644 util.c create mode 100644 util.o diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6ed8ad3 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +MIT/X Consortium License + +© 2006-2019 Anselm R Garbe +© 2006-2008 Sander van Dijk +© 2006-2007 Michał Janeczek +© 2007 Kris Maglione +© 2009 Gottox +© 2009 Markus Schnalke +© 2009 Evan Gates +© 2010-2012 Connor Lane Smith +© 2014-2019 Hiltjo Posthuma +© 2015-2018 Quentin Rameau + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/dmenu.c b/dmenu.c new file mode 100644 index 0000000..5400670 --- /dev/null +++ b/dmenu.c @@ -0,0 +1,780 @@ +/* See LICENSE file for copyright and license details. */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#ifdef XINERAMA +#include +#endif +#include + +#include "drw.h" +#include "util.h" + +//static const int vertpad = 10; +//static const int sidepad = 20; + + +/* macros */ +#define INTERSECT(x,y,w,h,r) (MAX(0, MIN((x)+(w),(r).x_org+(r).width) - MAX((x),(r).x_org)) \ + * MAX(0, MIN((y)+(h),(r).y_org+(r).height) - MAX((y),(r).y_org))) +#define LENGTH(X) (sizeof X / sizeof X[0]) +#define TEXTW(X) (drw_fontset_getwidth(drw, (X)) + lrpad) + +/* enums */ +enum { SchemeNorm, SchemeSel, SchemeOut, SchemeLast }; /* color schemes */ + +struct item { + char *text; + struct item *left, *right; + int out; +}; + +static char text[BUFSIZ] = ""; +static char *embed; +static int bh, mw, mh; +static int inputw = 0, promptw; +static int lrpad; /* sum of left and right padding */ +static size_t cursor; +static struct item *items = NULL; +static struct item *matches, *matchend; +static struct item *prev, *curr, *next, *sel; +static int mon = -1, screen; + +static Atom clip, utf8; +static Display *dpy; +static Window root, parentwin, win; +static XIC xic; + +static Drw *drw; +static Clr *scheme[SchemeLast]; + +#include "config.h" + +static int (*fstrncmp)(const char *, const char *, size_t) = strncmp; +static char *(*fstrstr)(const char *, const char *) = strstr; + +static void +appenditem(struct item *item, struct item **list, struct item **last) +{ + if (*last) + (*last)->right = item; + else + *list = item; + + item->left = *last; + item->right = NULL; + *last = item; +} + +static void +calcoffsets(void) +{ + int i, n; + + if (lines > 0) + n = lines * bh; + else + n = mw - (promptw + inputw + TEXTW("<") + TEXTW(">")); + /* calculate which items will begin the next page and previous page */ + for (i = 0, next = curr; next; next = next->right) + if ((i += (lines > 0) ? bh : MIN(TEXTW(next->text), n)) > n) + break; + for (i = 0, prev = curr; prev && prev->left; prev = prev->left) + if ((i += (lines > 0) ? bh : MIN(TEXTW(prev->left->text), n)) > n) + break; +} + +static void +cleanup(void) +{ + size_t i; + + XUngrabKey(dpy, AnyKey, AnyModifier, root); + for (i = 0; i < SchemeLast; i++) + free(scheme[i]); + drw_free(drw); + XSync(dpy, False); + XCloseDisplay(dpy); +} + +static char * +cistrstr(const char *s, const char *sub) +{ + size_t len; + + for (len = strlen(sub); *s; s++) + if (!strncasecmp(s, sub, len)) + return (char *)s; + return NULL; +} + +static int +drawitem(struct item *item, int x, int y, int w) +{ + if (item == sel) + drw_setscheme(drw, scheme[SchemeSel]); + else if (item->out) + drw_setscheme(drw, scheme[SchemeOut]); + else + drw_setscheme(drw, scheme[SchemeNorm]); + + return drw_text(drw, x, y, w, bh, lrpad / 2, item->text, 0); +} + +static void +drawmenu(void) +{ + unsigned int curpos; + struct item *item; + int x = 0, y = 0, w; + + drw_setscheme(drw, scheme[SchemeNorm]); + drw_rect(drw, 0, 0, mw, mh, 1, 1); + + if (prompt && *prompt) { + drw_setscheme(drw, scheme[SchemeSel]); + x = drw_text(drw, x, 0, promptw, bh, lrpad / 2, prompt, 0); + } + /* draw input field */ + w = (lines > 0 || !matches) ? mw - x : inputw; + drw_setscheme(drw, scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, lrpad / 2, text, 0); + + curpos = TEXTW(text) - TEXTW(&text[cursor]); + if ((curpos += lrpad / 2 - 1) < w) { + drw_setscheme(drw, scheme[SchemeNorm]); + drw_rect(drw, x + curpos, 2, 2, bh - 4, 1, 0); + } + + if (lines > 0) { + /* draw vertical list */ + for (item = curr; item != next; item = item->right) + drawitem(item, x, y += bh, mw - x); + } else if (matches) { + /* draw horizontal list */ + x += inputw; + w = TEXTW("<"); + if (curr->left) { + drw_setscheme(drw, scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, lrpad / 2, "<", 0); + } + x += w; + for (item = curr; item != next; item = item->right) + x = drawitem(item, x, 0, MIN(TEXTW(item->text), mw - x - TEXTW(">"))); + if (next) { + w = TEXTW(">"); + drw_setscheme(drw, scheme[SchemeNorm]); + drw_text(drw, mw - w, 0, w, bh, lrpad / 2, ">", 0); + } + } + drw_map(drw, win, 0, 0, mw, mh); +} + +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) + 1; + 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; + + if(instant && matches && matches==matchend && !lsubstr) { + puts(matches->text); + cleanup(); + exit(0); + } + + + 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 +movewordedge(int dir) +{ + if (dir < 0) { /* move cursor to the start of the word*/ + while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)])) + cursor = nextrune(-1); + while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)])) + cursor = nextrune(-1); + } else { /* move cursor to the end of the word */ + while (text[cursor] && strchr(worddelimiters, text[cursor])) + cursor = nextrune(+1); + while (text[cursor] && !strchr(worddelimiters, text[cursor])) + cursor = nextrune(+1); + } +} + +static void +keypress(XKeyEvent *ev) +{ + char buf[32]; + int len; + KeySym ksym; + Status status; + + len = XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status); + switch (status) { + default: /* XLookupNone, XBufferOverflow */ + return; + case XLookupChars: + goto insert; + case XLookupKeySym: + case XLookupBoth: + break; + } + + if (ev->state & ControlMask) { + switch(ksym) { + case XK_a: ksym = XK_Home; break; + case XK_b: ksym = XK_Left; break; + case XK_c: ksym = XK_Escape; break; + case XK_d: ksym = XK_Delete; break; + case XK_e: ksym = XK_End; break; + case XK_f: ksym = XK_Right; break; + case XK_g: ksym = XK_Escape; break; + case XK_h: ksym = XK_BackSpace; break; + case XK_i: ksym = XK_Tab; break; + case XK_j: /* fallthrough */ + case XK_J: /* fallthrough */ + case XK_m: /* fallthrough */ + case XK_M: ksym = XK_Return; ev->state &= ~ControlMask; break; + case XK_n: ksym = XK_Down; break; + case XK_p: ksym = XK_Up; break; + + case XK_k: /* delete right */ + text[cursor] = '\0'; + match(); + break; + case XK_u: /* delete left */ + insert(NULL, 0 - cursor); + break; + case XK_w: /* delete word */ + while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)])) + insert(NULL, nextrune(-1) - cursor); + while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)])) + insert(NULL, nextrune(-1) - cursor); + break; + case XK_y: /* paste selection */ + case XK_Y: + XConvertSelection(dpy, (ev->state & ShiftMask) ? clip : XA_PRIMARY, + utf8, utf8, win, CurrentTime); + return; + case XK_Left: + movewordedge(-1); + goto draw; + case XK_Right: + movewordedge(+1); + goto draw; + case XK_Return: + case XK_KP_Enter: + break; + case XK_bracketleft: + cleanup(); + exit(1); + default: + return; + } + } else if (ev->state & Mod1Mask) { + switch(ksym) { + case XK_b: + movewordedge(-1); + goto draw; + case XK_f: + movewordedge(+1); + goto draw; + case XK_g: ksym = XK_Home; break; + case XK_G: ksym = XK_End; break; + case XK_h: ksym = XK_Up; break; + case XK_j: ksym = XK_Next; break; + case XK_k: ksym = XK_Prior; break; + case XK_l: ksym = XK_Down; break; + default: + return; + } + } + + switch(ksym) { + default: +insert: + if (!iscntrl(*buf)) + insert(buf, len); + break; + case XK_Delete: + if (text[cursor] == '\0') + return; + cursor = nextrune(+1); + /* fallthrough */ + case XK_BackSpace: + if (cursor == 0) + return; + insert(NULL, nextrune(-1) - cursor); + break; + case XK_End: + if (text[cursor] != '\0') { + cursor = strlen(text); + break; + } + if (next) { + /* jump to end of list and position items in reverse */ + curr = matchend; + calcoffsets(); + curr = prev; + calcoffsets(); + while (next && (curr = curr->right)) + calcoffsets(); + } + sel = matchend; + break; + case XK_Escape: + cleanup(); + exit(1); + case XK_Home: + if (sel == matches) { + cursor = 0; + break; + } + sel = curr = matches; + calcoffsets(); + break; + case XK_Left: + if (cursor > 0 && (!sel || !sel->left || lines > 0)) { + cursor = nextrune(-1); + break; + } + if (lines > 0) + return; + /* fallthrough */ + case XK_Up: + if (sel && sel->left && (sel = sel->left)->right == curr) { + curr = prev; + calcoffsets(); + } + break; + case XK_Next: + if (!next) + return; + sel = curr = next; + calcoffsets(); + break; + case XK_Prior: + if (!prev) + return; + sel = curr = prev; + calcoffsets(); + break; + case XK_Return: + case XK_KP_Enter: + puts((sel && !(ev->state & ShiftMask)) ? sel->text : text); + if (!(ev->state & ControlMask)) { + cleanup(); + exit(0); + } + if (sel) + sel->out = 1; + break; + case XK_Right: + if (text[cursor] != '\0') { + cursor = nextrune(+1); + break; + } + if (lines > 0) + return; + /* fallthrough */ + case XK_Down: + if (sel && sel->right && (sel = sel->right) == next) { + curr = next; + calcoffsets(); + } + break; + case XK_Tab: + if (!sel) + return; + strncpy(text, sel->text, sizeof text - 1); + text[sizeof text - 1] = '\0'; + cursor = strlen(text); + match(); + break; + } + +draw: + drawmenu(); +} + +static void +paste(void) +{ + char *p, *q; + int di; + unsigned long dl; + Atom da; + + /* we have been given the current selection, now insert it into input */ + if (XGetWindowProperty(dpy, win, utf8, 0, (sizeof text / 4) + 1, False, + utf8, &da, &di, &dl, &dl, (unsigned char **)&p) + == Success && p) { + insert(p, (q = strchr(p, '\n')) ? q - p : (ssize_t)strlen(p)); + XFree(p); + } + drawmenu(); +} + +static void +readstdin(void) +{ + char buf[sizeof text], *p; + size_t i, imax = 0, size = 0; + unsigned int tmpmax = 0; + + /* read each line from stdin and add it to the item list */ + for (i = 0; fgets(buf, sizeof buf, stdin); i++) { + if (i + 1 >= size / sizeof *items) + if (!(items = realloc(items, (size += BUFSIZ)))) + die("cannot realloc %u bytes:", size); + if ((p = strchr(buf, '\n'))) + *p = '\0'; + if (!(items[i].text = strdup(buf))) + die("cannot strdup %u bytes:", strlen(buf) + 1); + items[i].out = 0; + drw_font_getexts(drw->fonts, buf, strlen(buf), &tmpmax, NULL); + if (tmpmax > inputw) { + inputw = tmpmax; + imax = i; + } + } + if (items) + items[i].text = NULL; + inputw = items ? TEXTW(items[imax].text) : 0; + lines = MIN(lines, i); +} + +static void +run(void) +{ + XEvent ev; + + while (!XNextEvent(dpy, &ev)) { + if (XFilterEvent(&ev, None)) + continue; + switch(ev.type) { + case Expose: + if (ev.xexpose.count == 0) + drw_map(drw, win, 0, 0, mw, mh); + break; + case FocusIn: + /* regrab focus from parent window */ + if (ev.xfocus.window != win) + grabfocus(); + break; + case KeyPress: + keypress(&ev.xkey); + break; + case SelectionNotify: + if (ev.xselection.property == utf8) + paste(); + break; + case VisibilityNotify: + if (ev.xvisibility.state != VisibilityUnobscured) + XRaiseWindow(dpy, win); + break; + } + } +} + +static void +setup(void) +{ + int x, y, i, j; + unsigned int du; + XSetWindowAttributes swa; + XIM xim; + Window w, dw, *dws; + XWindowAttributes wa; + XClassHint ch = {"dmenu", "dmenu"}; +#ifdef XINERAMA + XineramaScreenInfo *info; + Window pw; + int a, di, n, area = 0; +#endif + /* init appearance */ + for (j = 0; j < SchemeLast; j++) + scheme[j] = drw_scm_create(drw, colors[j], 2); + + clip = XInternAtom(dpy, "CLIPBOARD", False); + utf8 = XInternAtom(dpy, "UTF8_STRING", False); + + /* calculate menu geometry */ + bh = drw->fonts->h + 2; + lines = MAX(lines, 0); + mh = (lines + 1) * bh; +#ifdef XINERAMA + i = 0; + if (parentwin == root && (info = XineramaQueryScreens(dpy, &n))) { + XGetInputFocus(dpy, &w, &di); + if (mon >= 0 && mon < n) + i = mon; + else if (w != root && w != PointerRoot && w != None) { + /* find top-level window containing current input focus */ + do { + if (XQueryTree(dpy, (pw = w), &dw, &w, &dws, &du) && dws) + XFree(dws); + } while (w != root && w != pw); + /* find xinerama screen with which the window intersects most */ + if (XGetWindowAttributes(dpy, pw, &wa)) + for (j = 0; j < n; j++) + if ((a = INTERSECT(wa.x, wa.y, wa.width, wa.height, info[j])) > area) { + area = a; + i = j; + } + } + /* no focused window is on screen, so use pointer location instead */ + if (mon < 0 && !area && XQueryPointer(dpy, root, &dw, &dw, &x, &y, &di, &di, &du)) + for (i = 0; i < n; i++) + if (INTERSECT(x, y, 1, 1, info[i])) + break; + + x = info[i].x_org + sidepad; + y = info[i].y_org + (topbar ? 0 : info[i].height - mh) + vertpad; + mw = info[i].width - 2*sidepad; + XFree(info); + } else +#endif + { + if (!XGetWindowAttributes(dpy, parentwin, &wa)) + die("could not get embedding window attributes: 0x%lx", + parentwin); + x = 0; + y = topbar ? 0 : wa.height - mh; + mw = wa.width; + } + promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0; + inputw = MIN(inputw, mw/3); + match(); + + /* create menu window */ + swa.override_redirect = True; + swa.background_pixel = scheme[SchemeNorm][ColBg].pixel; + swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask; + win = XCreateWindow(dpy, parentwin, x, y, mw, mh, 0, + CopyFromParent, CopyFromParent, CopyFromParent, + CWOverrideRedirect | CWBackPixel | CWEventMask, &swa); + XSetClassHint(dpy, win, &ch); + + /* open input methods */ + xim = XOpenIM(dpy, NULL, NULL, NULL); + xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, + XNClientWindow, win, XNFocusWindow, win, NULL); + + XMapRaised(dpy, win); + XSetInputFocus(dpy, win, RevertToParent, CurrentTime); + if (embed) { + XSelectInput(dpy, parentwin, FocusChangeMask); + if (XQueryTree(dpy, parentwin, &dw, &w, &dws, &du) && dws) { + for (i = 0; i < du && dws[i] != win; ++i) + XSelectInput(dpy, dws[i], FocusChangeMask); + XFree(dws); + } + grabfocus(); + } + drw_resize(drw, mw, mh); + drawmenu(); +} + +static void +usage(void) +{ + fputs("usage: dmenu [-bfinv] [-l lines] [-p prompt] [-fn font] [-m monitor]\n" + " [-nb color] [-nf color] [-sb color] [-sf color] [-w windowid]\n", stderr); + exit(1); +} + +int +main(int argc, char *argv[]) +{ + XWindowAttributes wa; + int i, fast = 0; + + for (i = 1; i < argc; i++) + /* these options take no arguments */ + if (!strcmp(argv[i], "-v")) { /* prints version information */ + puts("dmenu-"VERSION); + exit(0); + } else if (!strcmp(argv[i], "-b")) /* appears at the bottom of the screen */ + topbar = 0; + else if (!strcmp(argv[i], "-f")) /* grabs keyboard before reading stdin */ + fast = 1; + else if (!strcmp(argv[i], "-i")) { /* case-insensitive item matching */ + fstrncmp = strncasecmp; + fstrstr = cistrstr; + } else if (!strcmp(argv[i], "-n")) /* instant select only match */ + instant = 1; + else if (i + 1 == argc) + usage(); + /* these options take one argument */ + else if (!strcmp(argv[i], "-l")) /* number of lines in vertical list */ + lines = atoi(argv[++i]); + else if (!strcmp(argv[i], "-m")) + mon = atoi(argv[++i]); + else if (!strcmp(argv[i], "-p")) /* adds prompt to left of input field */ + prompt = argv[++i]; + else if (!strcmp(argv[i], "-fn")) /* font or font set */ + fonts[0] = argv[++i]; + else if (!strcmp(argv[i], "-nb")) /* normal background color */ + colors[SchemeNorm][ColBg] = argv[++i]; + else if (!strcmp(argv[i], "-nf")) /* normal foreground color */ + colors[SchemeNorm][ColFg] = argv[++i]; + else if (!strcmp(argv[i], "-sb")) /* selected background color */ + colors[SchemeSel][ColBg] = argv[++i]; + else if (!strcmp(argv[i], "-sf")) /* selected foreground color */ + colors[SchemeSel][ColFg] = argv[++i]; + else if (!strcmp(argv[i], "-w")) /* embedding window id */ + embed = argv[++i]; + else + usage(); + + if (!setlocale(LC_CTYPE, "") || !XSupportsLocale()) + fputs("warning: no locale support\n", stderr); + if (!XSetLocaleModifiers("")) + fputs("warning: no locale modifiers support\n", stderr); + if (!(dpy = XOpenDisplay(NULL))) + die("cannot open display"); + screen = DefaultScreen(dpy); + root = RootWindow(dpy, screen); + if (!embed || !(parentwin = strtol(embed, NULL, 0))) + parentwin = root; + if (!XGetWindowAttributes(dpy, parentwin, &wa)) + die("could not get embedding window attributes: 0x%lx", + parentwin); + drw = drw_create(dpy, screen, root, wa.width, wa.height); + if (!drw_fontset_create(drw, fonts, LENGTH(fonts))) + die("no fonts could be loaded."); + lrpad = drw->fonts->h; + +#ifdef __OpenBSD__ + if (pledge("stdio rpath", NULL) == -1) + die("pledge"); +#endif + + if (fast && !isatty(0)) { + grabkeyboard(); + readstdin(); + } else { + readstdin(); + grabkeyboard(); + } + setup(); + run(); + + return 1; /* unreachable */ +} diff --git a/dmenu.o b/dmenu.o new file mode 100644 index 0000000000000000000000000000000000000000..edad3acae1db9b173a61df22ed1132dbb224c6ba GIT binary patch literal 33040 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 + +#include +#include +#include +#include +#include +#include + +#include "arg.h" +char *argv0; + +#define FLAG(x) (flag[(x)-'a']) + +static void test(const char *, const char *); +static void usage(void); + +static int match = 0; +static int flag[26]; +static struct stat old, new; + +static void +test(const char *path, const char *name) +{ + struct stat st, ln; + + if ((!stat(path, &st) && (FLAG('a') || name[0] != '.') /* hidden files */ + && (!FLAG('b') || S_ISBLK(st.st_mode)) /* block special */ + && (!FLAG('c') || S_ISCHR(st.st_mode)) /* character special */ + && (!FLAG('d') || S_ISDIR(st.st_mode)) /* directory */ + && (!FLAG('e') || access(path, F_OK) == 0) /* exists */ + && (!FLAG('f') || S_ISREG(st.st_mode)) /* regular file */ + && (!FLAG('g') || st.st_mode & S_ISGID) /* set-group-id flag */ + && (!FLAG('h') || (!lstat(path, &ln) && S_ISLNK(ln.st_mode))) /* symbolic link */ + && (!FLAG('n') || st.st_mtime > new.st_mtime) /* newer than file */ + && (!FLAG('o') || st.st_mtime < old.st_mtime) /* older than file */ + && (!FLAG('p') || S_ISFIFO(st.st_mode)) /* named pipe */ + && (!FLAG('r') || access(path, R_OK) == 0) /* readable */ + && (!FLAG('s') || st.st_size > 0) /* not empty */ + && (!FLAG('u') || st.st_mode & S_ISUID) /* set-user-id flag */ + && (!FLAG('w') || access(path, W_OK) == 0) /* writable */ + && (!FLAG('x') || access(path, X_OK) == 0)) != FLAG('v')) { /* executable */ + if (FLAG('q')) + exit(0); + match = 1; + puts(name); + } +} + +static void +usage(void) +{ + fprintf(stderr, "usage: %s [-abcdefghlpqrsuvwx] " + "[-n file] [-o file] [file...]\n", argv0); + exit(2); /* like test(1) return > 1 on error */ +} + +int +main(int argc, char *argv[]) +{ + struct dirent *d; + char path[PATH_MAX], *line = NULL, *file; + size_t linesiz = 0; + ssize_t n; + DIR *dir; + int r; + + ARGBEGIN { + case 'n': /* newer than file */ + case 'o': /* older than file */ + file = EARGF(usage()); + if (!(FLAG(ARGC()) = !stat(file, (ARGC() == 'n' ? &new : &old)))) + perror(file); + break; + default: + /* miscellaneous operators */ + if (strchr("abcdefghlpqrsuvwx", ARGC())) + FLAG(ARGC()) = 1; + else + usage(); /* unknown flag */ + } ARGEND; + + if (!argc) { + /* read list from stdin */ + while ((n = getline(&line, &linesiz, stdin)) > 0) { + if (n && line[n - 1] == '\n') + line[n - 1] = '\0'; + test(line, line); + } + free(line); + } else { + for (; argc; argc--, argv++) { + if (FLAG('l') && (dir = opendir(*argv))) { + /* test directory contents */ + while ((d = readdir(dir))) { + r = snprintf(path, sizeof path, "%s/%s", + *argv, d->d_name); + if (r >= 0 && (size_t)r < sizeof path) + test(path, d->d_name); + } + closedir(dir); + } else { + test(*argv, *argv); + } + } + } + return match ? 0 : 1; +} diff --git a/stest.o b/stest.o new file mode 100644 index 0000000000000000000000000000000000000000..f3d919245e6349c6d04b5a070963273e6939475b GIT binary patch literal 5296 zcmb<-^>JfjWMqH=Mg}_u1P><4!0M8(U|{g*Y*Eo*WMD8n;L%&6!U0y? zdZ2{e@W9LCj0_CTV8a!TpqLdrTDA9Z^Z1~Ni^F7QB&tI1R|NkG!q6P*A{?_FG|Np~uaDQ`AQDot7 z@kfXujB|Z$=+V1HWd_)jFhluUl|g2m8uvQKGvKL?J?pf64*=Z3kY9?E^(QLb&AAOQV1P|678+RiXqn zqJ-V>KRA?+gT+B6`E))9i+FUmfYU>YhcP69l(0g?8;^j}O{`@`^0$6qU|{G9U~IX>-|`eB_Di=^u%Uv9p_JRB`7p=-voFts zBI^GE&(1rppd`uc+pVMG*!+#rvCEaA>OFfe#p-r;YZ!oa}5zwbkD z*d&+UviZ%w7|UZF8)_LDO8I@eb5uBdTi=#)fkV;r|IycM|Id0hAK|dcgJxNu&iB5_ z-#mIDPUUy~09I*usr3N=lta#)BHJCoQC*_x1I-$*)9Kl!twI=zyJSR-vEG0p`B0^ysz*vphSGg4_@TbDl@* zfl_HW2OORyKCpym_WFcRZ-TH#H#exj0hd(1oe%ag2rw}Cbbbe$XZxR@fuVe(Pvlx@8YC;&Ggu}qVAOfWstAZF9D+Cy&dDuB7FfxD~$RGoi zQwPzGd;*~I(*VR~U|{e8TEhj(i4fY%Y8j&FtQM4-}X+nfNRm`3xNSG@SSpocJW1 zpk_gh!AgOW01Ly%|JWp%vDPdM49pD7*pxFcGk^*#Oetmta9Tx?;ACK6U_vq<97dpQ z0TqYw!QliAXGR7V1_zLX85kHcpr%POFff3`p|$mH zHmGV;ikSiAT2wI*kC}lBM4@1ayD|N%16IY#UksY6w zn3=@Pc9541KmthV zq#A0z6;vFg7C9X{K*d26NNxdCJ*<8MiAf{HOA1IK)SaMq1S~zkY8H?*NRJKF950Zg zpzcA=FR*k4QV+r~bHGg}sCtk&F!8TQ=77XOy;y zC#Y==GhZDl4pJ|Vq#hQ2AoU;&%g;?v^&l|?B=!AJagaHnIvr;IJS1@?B=yMkJ;-dB zdT{Ru>Ms=}^+%D+QAHBJ3>62t2V{3Tl>Y)sgTw`q)c=5rgVd@aiF1JzLc<@#1i1+m z#Nr?h7I8%+agbTC{9_9h2ZKNvfW^U#Kp)?t!XJ&4^DcO3Y1#+D{<`3I|XWpttNG zV8r*QD6QKH6z(pVo znEN3-28JAH*#Zg&m>7r#^)^AY2Z&%`U;z0al%!z#VgAQvH%N;GD6kk97*;^zftP`S z0o1NS*U!lS>aT%xpyCH02?hp+i>Sg#Ju-*{s4Rn80TF +#include +#include +#include + +#include "util.h" + +void * +ecalloc(size_t nmemb, size_t size) +{ + void *p; + + if (!(p = calloc(nmemb, size))) + die("calloc:"); + return p; +} + +void +die(const char *fmt, ...) { + va_list ap; + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + + if (fmt[0] && fmt[strlen(fmt)-1] == ':') { + fputc(' ', stderr); + perror(NULL); + } else { + fputc('\n', stderr); + } + + exit(1); +} diff --git a/util.o b/util.o new file mode 100644 index 0000000000000000000000000000000000000000..59a07457a785bae0ce4bed63b5ac76e960595509 GIT binary patch literal 2224 zcmb<-^>JfjWMqH=Mg}_u1P><4z)--7U^{@B4h*~uJPe^8oqs(V-&|l|VDRWHQPJ?| z3{f%g==4#s@ac3>aq#K%QSoRwP-4!n>7o+Auj!+bz^@siQoye{N2P&*fq`FhiOK{p zy+&mLnBJnY0Zi{vIl#cckmAwJqN)Kl+(kvg@PJ3REy!|@&UYT2k34!?R30!eFdS!5 z;eaaP@aT0>Q8@0R!eRgw5qJU8&``_3;L&XgVwPxlG@tx$c)+9c{ik&v-!C@Q@cy$Z z72dDFz`y`jYxo~bz2@4_1ryp23KFnrAei)MJy6Qy(F=A9SRm?fa$-(SezFwgAkJY!C}R~z#z!Lz#srs zgG_OGq%ouwl$Inj6r>gvE!25trhhClxyU@=r26tkc(g^90&ileJP4;2Tg=R-2*8j?6a zlK3Meab)#xkiVFI81zySOA;CMl8TEN z^osI99FTHDJwpb)>vpg(3Kw$~e3kqwH8c_ZL(P|6~;9Lh) z4iW-mPmp3T3za|@)?r`(=YDea8$#_jLbZkgW|WY;)uT+ zpbW{tzyR|XDE>ftK^SBdEdD^&pxX_SKLL_pU|@jJpfUnx21p*JpOXPpKY&C~@dRju g2BHeX!wn`3DxaZBVM1V<16uTFfO!Z4>MXbb0Dct&DgXcg literal 0 HcmV?d00001