suckless-desktop/dmenu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hail dmenuc

Browse Source
This commit is contained in:
Андреев Григорий 2025-04-01 16:56:23 +03:00
parent 15f0add690
commit 6a3e21f568
6 changed files with 233 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -5,4 +5,6 @@ config.h
stest
*.tar
*.gz
test_collect_options.sh
shell.nix

11
Makefile
View File

@ -24,8 +24,8 @@ clean:
dist: clean
mkdir -p dmenu-$(VERSION)
cp LICENSE Makefile dmenu_run.sh README arg.h config.def.h config.mk dmenu.1\
drw.h util.h stest.1 $(SRC)\
cp LICENSE Makefile README arg.h config.def.h config.mk dmenu.1\
drw.h util.h stest.1 dmenuc.py $(SRC)\
dmenu-$(VERSION)
tar -cf dmenu-$(VERSION).tar dmenu-$(VERSION)
gzip dmenu-$(VERSION).tar
@ -33,9 +33,8 @@ dist: clean
install: all
mkdir -p $(DESTDIR)$(PREFIX)/bin
cp -f dmenu dmenu_run.sh stest $(DESTDIR)$(PREFIX)/bin
cp -f dmenu stest dmenuc.py $(DESTDIR)$(PREFIX)/bin
chmod 755 $(DESTDIR)$(PREFIX)/bin/stest
chmod 755 $(DESTDIR)$(PREFIX)/bin/dmenu_run.sh
chmod 755 $(DESTDIR)$(PREFIX)/bin/dmenu
mkdir -p $(DESTDIR)$(MANPREFIX)/man1
sed "s/VERSION/$(VERSION)/g" < dmenu.1 > $(DESTDIR)$(MANPREFIX)/man1/dmenu.1
@ -45,9 +44,7 @@ install: all
uninstall:
rm -f $(DESTDIR)$(PREFIX)/bin/dmenu\
$(DESTDIR)$(PREFIX)/bin/dmenu_run\
$(DESTDIR)$(PREFIX)/bin/dmenu_run.sh\
$(DESTDIR)$(PREFIX)/bin/dmenu_path\
$(DESTDIR)$(PREFIX)/bin/dmenuc.py
$(DESTDIR)$(PREFIX)/bin/stest\
$(DESTDIR)$(MANPREFIX)/man1/dmenu.1\
$(DESTDIR)$(MANPREFIX)/man1/stest.1

8
config.def.h
View File

@ -15,10 +15,10 @@ static const char *prompt = NULL; /* -p option; prompt to the left of
static const char *colors[SchemeLast][2] = {
/* fg bg */
[SchemeNorm] = { "#dddddd", "#111111" },
[SchemeSel] = { "#ffffff", "#ff0000" },
[SchemeOut] = { "#000000", "#bc3d2f" },
[SchemeCaret] = { "#fe5e5e", "#222222" },
[SchemeBorder] = { "#dc0000", NULL },
[SchemeSel] = { "#000000", "#ffd000" },
[SchemeOut] = { "#000000", "#bcad1f" },
[SchemeCaret] = { "#fede5e", NULL },
[SchemeBorder] = { "#dcf000", NULL },
};
/* -l and -g options; controls number of lines and columns in grid if > 0 */

19
dmenu.c
View File

@ -618,12 +618,14 @@ paste(void)
static void
readstdin(void)
{
char *line = NULL, *p;
char *line = NULL;
size_t i, itemsiz = 0, linesiz = 0;
ssize_t len;
/* read each line from stdin and add it to the item list */
for (i = 0; (len = getline(&line, &linesiz, stdin)) != -1; i++) {
/* Reading each line from stdin. If it contains tab, we split it into stext and text.
* Otherwise we don't even add it. stext is what will be show.
* text is what will be put to stdout */
for (i = 0; (len = getline(&line, &linesiz, stdin)) != -1;) {
if (i + 1 >= itemsiz) {
itemsiz += 256;
if (!(items = realloc(items, itemsiz * sizeof(*items))))
@ -631,13 +633,16 @@ readstdin(void)
}
if (line[len - 1] == '\n')
line[len - 1] = '\0';
if (!(items[i].text = strdup(line)))
char* second_part = strchr(line, '\t');
if (!second_part)
continue;
if (!(items[i].text = strdup(second_part + 1)))
die("strdup:");
if ((p = strchr(line, '\t')))
*p = '\0';
*second_part = '\0';
if (!(items[i].stext = strdup(line)))
die("cannot strdup bytes:");
die("strdup:");
items[i].out = 0;
i++;
}
free(line);
if (items)

13
dmenu_run.sh
View File

@ -1,13 +0,0 @@
#!/bin/bash
FILE="$HOME/.config/suckless_desktop/win_r.txt"
if [ ! -f "$FILE" ]; then
echo "File not found: $FILE" >&2
exit 1
fi
sed 's/|/'$'\t''/' "$FILE" | dmenu "$@" | {
IFS=$'\t' read -r col1 col2
[ -z "$col2" ] && exit 0
eval "$col2" 2>/dev/null || :
}

211
dmenuc.py Executable file
View File

@ -0,0 +1,211 @@
#!/usr/bin/env python3
import re
import sys
import argparse
import os
import stat
from dataclasses import dataclass
from typing import List, Union
TOKEN_SPECIFICATION = [
('IMPORT', r'import'),
('EVAL', r'eval'),
('OPTION', r'option'),
('DMENU', r'dmenu'),
('LPAREN', r'\('),
('RPAREN', r'\)'),
('STRING', r'"(?:\\.|[^"\\])*"|\'[^\']*\'|`[^`]*`'),
('SKIP', r'[\n \t]+'),
('MISMATCH', r'.'),
]
TOKEN_REGEX = '|'.join(f'(?P<{name}>{pattern})' for name, pattern in TOKEN_SPECIFICATION)
@dataclass
class Token:
type: str
value: str
pos: int
def __repr__(self):
return f'Token({self.type}, {self.value}, pos={self.pos})'
def tokenize(code):
tokens = []
for mo in re.finditer(TOKEN_REGEX, code):
kind = mo.lastgroup
value = mo.group()
pos = mo.start()
if kind == 'SKIP':
continue
elif kind == 'MISMATCH':
raise RuntimeError(f'Unexpected token {value!r} at position {pos}')
else:
tokens.append(Token(kind, value, pos))
return tokens
def restore_string(string_tkn_val: str):
if string_tkn_val[0] == '"':
return string_tkn_val[1:-1].replace("\\\"", "\"").replace("\\\\", "\\")
else:
return string_tkn_val[1:-1]
class ActionDmenu:
...
@dataclass
class OptionInDmenu:
label: str
action: Union[ActionDmenu, str]
def __repr__(self):
if isinstance(self.action, ActionDmenu):
return f"option {self.label} {self.action}"
else:
return f"option {self.label} eval {self.action}"
@dataclass
class ActionDmenu:
prompt: str
options: List[OptionInDmenu]
def __repr__(self):
return f"dmenu {self.prompt} ( {' ; '.join(map(str, self.options))} )"
class Parser:
def __init__(self, tokens):
self.tokens = tokens
self.pos = 0
def current(self):
if self.pos < len(self.tokens):
return self.tokens[self.pos]
return None
def eat(self, token_type) -> Token:
token = self.current()
if token is None:
raise RuntimeError("Unexpected end of input")
if token.type == token_type:
self.pos += 1
return token
raise RuntimeError(f"Expected token {token_type} at position {token.pos} but got {token.type}")
# Grammar production: <option> ::= option <string> ( eval <string> | <dmenu> )
def parse_option(self):
self.eat('OPTION')
label_tkn = self.eat('STRING')
label = restore_string(label_tkn.value)
if '\t' in label or '\n' in label or '\000' in label:
raise RuntimeError(f"Label of option at {label_tkn.pos} contains illegal character")
current = self.current()
if current is None:
raise RuntimeError("Expected end-of-file after option")
if current.type == 'EVAL':
self.eat('EVAL')
action_command_tkn = self.eat('STRING').value
action = restore_string(action_command_tkn)
if '\n' in action or '\000' in action:
raise RuntimeError(f"Command at {action_command_tkn.pos} contains illegal character")
elif current.type == 'DMENU':
action = self.parse_dmenu()
else:
raise RuntimeError(f"Unexpected token {current.type} in option at position {current.pos}")
return OptionInDmenu(label, action)
# Grammar production: <dmenu> ::= dmenu <string> \( <option> * \)
def parse_dmenu(self):
self.eat('DMENU')
prompt = restore_string(self.eat('STRING').value)
self.eat('LPAREN')
options = []
while self.current() is not None and self.current().type != 'RPAREN':
options.append(self.parse_option())
self.eat('RPAREN')
return ActionDmenu(prompt, options)
def parse_file_as_dmenu(self):
node = self.parse_dmenu()
if self.current() is not None:
raise RuntimeError("Extra tokens after valid dmenu")
return node
def shell_escape(s: str) -> str:
return "'" + s.replace("'", "'\\''") + "'"
def write_to_file(path: str, text: str) -> None:
with open(path, "w", encoding="utf-8") as f:
f.write(text)
def make_file_executable(path: str):
old = os.stat(path).st_mode
os.chmod(path, old | stat.S_IXUSR | stat.S_IXGRP)
def generate_tsv_file(dpath: str, cur_tsv_name, options: List[OptionInDmenu]):
def option_to_line(i: int) -> str:
opt = options[i]
if isinstance(opt.action, ActionDmenu):
child_tsv_name = f"{cur_tsv_name}-{i}"
generate_tsv_file(dpath, child_tsv_name, opt.action.options)
return f"{opt.label}\t<{shell_escape(os.path.join(dpath, child_tsv_name))} dmenu " + \
f"-p {shell_escape(opt.action.prompt)} | tail -n 1 | sh"
else:
return f"{opt.label}\t{opt.action}"
write_to_file(
os.path.join(dpath, cur_tsv_name),
"\n".join(map(option_to_line, range(len(options))))
)
def compile_dmenuctree(dpath: str, parsed_tree: ActionDmenu):
print(f"dmenu tabfiles root is {dpath}")
main_script = os.path.join(dpath, "invoke.sh")
cur_tsv_name = "tsv"
invoke_snippet = f"#!/bin/sh\n" + \
f"<{shell_escape(os.path.join(dpath, cur_tsv_name))} dmenu -p {shell_escape(parsed_tree.prompt)} " + \
f"| tail -n 1 | sh"
write_to_file(main_script, invoke_snippet)
make_file_executable(main_script)
generate_tsv_file(dpath, cur_tsv_name, parsed_tree.options)
def main():
parser_arg = argparse.ArgumentParser(description="Parse a file using custom dmenu syntax")
parser_arg.add_argument("input_file", help="Path to the input file")
parser_arg.add_argument("dest_dir", help="Destination directory path")
args = parser_arg.parse_args()
if not os.path.exists(args.input_file):
print("Input file does not exist.", file=sys.stderr)
sys.exit(1)
if not os.path.isdir(args.dest_dir):
os.mkdir(args.dest_dir)
with open(args.input_file, 'r') as f:
code = f.read()
try:
tokens = tokenize(code)
parsed_tree = Parser(tokens).parse_file_as_dmenu()
except Exception as e:
print(f"Error during parsing: {e}", file=sys.stderr)
sys.exit(1)
compile_dmenuctree(os.path.realpath(args.dest_dir), parsed_tree)
if __name__ == '__main__':
main()