op public repos

Blob

Date:: Wed Nov 3 22:07:57 2021 UTC
Message:: drop leading T from token names
Actions:: History | Blame | Raw File
1 /*
2  * Much of the design is taken from doas (parse.y rev 1.29)
3  *
4  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
5  * Copyright (c) 2015 Ted Unangst <tedu@openbsd.org>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  *
19  */
20 
21 %{
22 
23 #include "telescope.h"
24 
25 #include <phos/phos.h>
26 
27 #include <assert.h>
28 #include <ctype.h>
29 #include <limits.h>
30 #include <ncurses.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 
36 typedef struct {
37 	union {
38 		char	*str;
39 		int	 num;
40 	};
41 	int lineno;
42 	int colno;
43 } yystype;
44 #define YYSTYPE yystype
45 
46 static char *current_style;
47 static int color_type;
48 
49 static const char *path;
50 
51 FILE *yyfp;
52 
53 int parse_errors = 0;
54 
55 static void yyerror(const char *, ...);
56 static int yylex(void);
57 static void setprfx(const char *, const char *);
58 static void setvari(char *, int);
59 static void setvars(char *, char *);
60 static int colorname(const char *);
61 static void setcolor(const char *, const char *, const char *);
62 static int attrname(const char *);
63 static void setattr(char *, char *, char *);
64 static void add_proxy(char *, char *);
65 static void bindkey(const char *, const char *, const char *);
66 static void do_parseconfig(const char *, int);
67 
68 %}
69 
70 %token SET
71 %token STYLE PRFX CONT BG FG ATTR
72 %token BIND UNBIND
73 %token PROXY VIA
74 
75 %token <str> STRING
76 %token <num> NUMBER
77 
78 %%
79 
80 grammar		: /* empty */
81 		| grammar '\n'
82 		| grammar rule '\n'
83 		| error '\n'
84 		;
85 
86 rule		: set
87 		| style {
88 			free(current_style);
89 			current_style = NULL;
90 		}
91 		| bind
92 		| unbind
93 		| proxy
94 		;
95 
96 set		: SET STRING '=' STRING	{ setvars($2, $4); }
97 		| SET STRING '=' NUMBER	{ setvari($2, $4); }
98 		;
99 
100 style		: STYLE STRING { current_style = $2; } stylespec ;
101 stylespec	: styleopt | '{' optnl styleopts '}' ;
102 
103 styleopts	: /* empty */
104 		| styleopts styleopt optnl
105 		;
106 
107 styleopt	: PRFX STRING		{ setprfx($2, $2); }
108 		| PRFX STRING STRING	{ setprfx($2, $3); }
109 		| BG { color_type = BG; } colorspec
110 		| FG { color_type = FG; } colorspec
111 		| ATTR attr
112 		;
113 
114 colorspec	: STRING			{ setcolor($1, $1, $1); free($1); }
115 		| STRING STRING		{ setcolor($1, $2, $1); free($1); free($2); }
116 		| STRING STRING STRING	{ setcolor($1, $2, $3); free($1); free($2); free($3); }
117 		;
118 
119 attr		: STRING			{ setattr($1, $1, $1); free($1); }
120 		| STRING STRING		{ setattr($1, $2, $1); free($1); free($2); }
121 		| STRING STRING STRING	{ setattr($1, $2, $3); free($1); free($2); free($3); }
122 		;
123 
124 bind		: BIND STRING STRING STRING	{ bindkey($2, $3, $4); free($2); free($3); free($4); }
125 		;
126 
127 unbind		: UNBIND STRING STRING	{ yyerror("TODO: unbind %s %s", $2, $3); }
128 		;
129 
130 proxy		: PROXY STRING VIA STRING { add_proxy($2, $4); free($4); }
131 		;
132 
133 optnl		: '\n' optnl	/* zero or more newlines */
134 		| /* empty */
135 		;
136 
137 %%
138 
139 void
140 yyerror(const char *fmt, ...)
141 {
142 	va_list va;
143 
144 	fprintf(stderr, "%s:%d ", path, yylval.lineno+1);
145 	va_start(va, fmt);
146 	vfprintf(stderr, fmt, va);
147 	va_end(va);
148 	fprintf(stderr, "\n");
149 	parse_errors++;
150 }
151 
152 static struct keyword {
153 	const char *word;
154 	int token;
155 } keywords[] = {
156 	{ "attr", ATTR },
157 	{ "bg", BG },
158 	{ "bind", BIND },
159 	{ "cont", CONT },
160 	{ "fg", FG },
161 	{ "prefix", PRFX },
162 	{ "proxy", PROXY },
163 	{ "set", SET },
164 	{ "style", STYLE },
165 	{ "unbind", UNBIND },
166 	{ "via", VIA },
167 };
168 
169 int
170 yylex(void)
171 {
172 	char buf[1024], *ebuf, *p, *str;
173 	const char *errstr;
174 	int c, quotes = 0, escape = 0, qpos = -1, nonkw = 0;
175 	size_t i;
176 
177 	p = buf;
178 	ebuf = buf + sizeof(buf);
179 
180 repeat:
181 	/* skip whitespace first */
182 	for (c = getc(yyfp); c == ' ' || c == '\t' || c == '\f'; c = getc(yyfp))
183 		yylval.colno++;
184 
185 	/* check for special one-character constructions */
186 	switch (c) {
187 	case '\r':
188 		/* silently eat up any \r */
189 		goto repeat;
190 	case '\n':
191 		yylval.colno = 0;
192 		yylval.lineno++;
193 		/* fallthrough */
194 	case '{':
195 	case '}':
196 	case '=':
197 		return c;
198 	case '#':
199 		/* skip comments; NUL is allowed; no continuation */
200 		while ((c = getc(yyfp)) != '\n')
201 			if (c == EOF)
202 				goto eof;
203 		yylval.colno = 0;
204 		yylval.lineno++;
205 		return c;
206 	case EOF:
207 		goto eof;
208 	}
209 
210 	/* parsing next word */
211 	for (;; c = getc(yyfp), yylval.colno++) {
212 		switch (c) {
213 		case '\0':
214 			yyerror("unallowed character NULL in column %d",
215 			    yylval.colno+1);
216 			escape = 0;
217 			continue;
218 		case '\\':
219 			escape = !escape;
220 			if (escape)
221 				continue;
222 			break;
223 		case '\r':
224 			/* ignore \r here too */
225 			continue;
226 		case '\n':
227 			if (quotes)
228 				yyerror("unterminated quotes in column %d",
229 				    yylval.colno+1);
230 			if (escape) {
231 				nonkw = 1;
232 				escape = 0;
233 				yylval.colno = 0;
234 				yylval.lineno++;
235 			}
236 			goto eow;
237 		case EOF:
238 			if (escape)
239 				yyerror("unterminated escape in column %d",
240 				    yylval.colno);
241 			if (quotes)
242 				yyerror("unterminated quotes in column %d",
243 				    qpos + 1);
244 			goto eow;
245 		case '{':
246 		case '}':
247 		case '=':
248 		case '#':
249 		case ' ':
250 		case '\t':
251 			if (!escape && !quotes)
252 				goto eow;
253 			break;
254 		case '"':
255 			if (!escape) {
256 				quotes = !quotes;
257 				if (quotes) {
258 					nonkw = 1;
259 					qpos = yylval.colno;
260 				}
261 				continue;
262 			}
263 		}
264 		*p++ = c;
265 		if (p == ebuf) {
266 			yyerror("line too long");
267 			p = buf;
268 		}
269 		escape = 0;
270 	}
271 
272 eow:
273 	*p = 0;
274 	if (c != EOF)
275 		ungetc(c, yyfp);
276 	if (p == buf) {
277 		/*
278 		 * There could be a number of reason for empty buffer,
279 		 * and we handle all of them here, to avoid cluttering
280 		 * the main loop.
281 		 */
282 		if (c == EOF)
283 			goto eof;
284 		else if (qpos == -1) /* accept, e.g., empty args: cmd foo args "" */
285 			goto repeat;
286 	}
287 	if (!nonkw) {
288 		for (i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
289 			if (strcmp(buf, keywords[i].word) == 0)
290 				return keywords[i].token;
291 		}
292 	}
293 	c = *buf;
294 	if (!nonkw && (c == '-' || isdigit(c))) {
295 		yylval.num = strtonum(buf, INT_MIN, INT_MAX, &errstr);
296 		if (errstr != NULL)
297 			yyerror("number is %s: %s", errstr, buf);
298 		return NUMBER;
299 	}
300 	if ((str = strdup(buf)) == NULL)
301 		err(1, "%s", __func__);
302 	yylval.str = str;
303 	return STRING;
304 
305 eof:
306 	if (ferror(yyfp))
307 		yyerror("input error reading config");
308 	return 0;
309 }
310 
311 static void
312 setprfx(const char *prfx, const char *cont)
313 {
314 	assert(current_style != NULL);
315 
316 	if (!config_setprfx(current_style, prfx, cont))
317 		yyerror("invalid style %s", current_style);
318 }
319 
320 static void
321 setvari(char *var, int val)
322 {
323 	if (!config_setvari(var, val))
324 		yyerror("invalid variable or value: %s = %d",
325 		    var, val);
326 
327 	free(var);
328 }
329 
330 static void
331 setvars(char *var, char *val)
332 {
333 	if (!config_setvars(var, val))
334 		yyerror("invalid variable or value: %s = \"%s\"",
335 		    var, val);
336 
337 	free(var);
338 }
339 
340 static int
341 colorname(const char *name)
342 {
343 	struct {
344 		const char	*name;
345 		short		 val;
346 	} *i, colors[] = {
347 		{ "default",	-1 },
348 		{ "black",	COLOR_BLACK },
349 		{ "red",	COLOR_RED },
350 		{ "green",	COLOR_GREEN },
351 		{ "yellow",	COLOR_YELLOW },
352 		{ "blue",	COLOR_BLUE },
353 		{ "magenta",	COLOR_MAGENTA },
354 		{ "cyan",	COLOR_CYAN },
355 		{ "white",	COLOR_WHITE },
356 		{ NULL, 0 },
357 	};
358 	const char *errstr;
359 	int n;
360 
361 	if (has_prefix(name, "colo")) {
362 		/* people are strange */
363 		if (has_prefix(name, "color"))
364 			name += 5;
365 		else if (has_prefix(name, "colour"))
366 			name += 6;
367 		else
368 			goto err;
369 
370 		n = strtonum(name, 0, 256, &errstr);
371 		if (errstr != NULL)
372 			yyerror("color number is %s: %s", errstr, name);
373 		return n;
374 	}
375 
376 	for (i = colors; i->name != NULL; ++i) {
377 		if (!strcmp(i->name, name))
378 			return i->val;
379 	}
380 
381 err:
382 	yyerror("unknown color name \"%s\"", name);
383 	return -1;
384 }
385 
386 void
387 setcolor(const char *prfx, const char *line, const char *trail)
388 {
389 	int p, l, t;
390 
391 	assert(current_style != NULL);
392 
393 	p = colorname(prfx);
394 	l = colorname(line);
395 	t = colorname(trail);
396 
397 	if (!config_setcolor(color_type == BG, current_style, p, l, t))
398 		yyerror("invalid style %s", current_style);
399 }
400 
401 static int
402 attrname(const char *n)
403 {
404 	struct {
405 		const char	*name;
406 		unsigned int	 val;
407 	} *i, attrs[] = {
408 		{ "normal",	A_NORMAL },
409 		{ "standout",	A_STANDOUT },
410 		{ "underline",	A_UNDERLINE },
411 		{ "reverse",	A_REVERSE },
412 		{ "blink",	A_BLINK },
413 		{ "dim",	A_DIM },
414 		{ "bold",	A_BOLD },
415 		{ NULL, 0 },
416 	};
417 	int ret, found;
418 	char *ap, *dup, *orig;
419 
420 	if ((dup = strdup(n)) == NULL)
421 		err(1, "strdup");
422 
423 	orig = dup;
424 
425 	ret = 0;
426 	while ((ap = strsep(&dup, ",")) != NULL) {
427 		if (*ap == '\0')
428 			continue;
429 
430 		found = 0;
431 		for (i = attrs; i ->name != NULL; ++i) {
432 			if (strcmp(i->name, ap))
433 				continue;
434 			ret |= i->val;
435 			found = 1;
436 			break;
437 		}
438 
439 		if (!found)
440 			yyerror("unknown attribute \"%s\" at col %d",
441 			    ap, yylval.colno+1);
442 	}
443 
444 	free(orig);
445 	return ret;
446 }
447 
448 static void
449 setattr(char *prfx, char *line, char *trail)
450 {
451 	int p, l, t;
452 
453 	assert(current_style != NULL);
454 
455 	p = attrname(prfx);
456 	l = attrname(line);
457 	t = attrname(trail);
458 
459 	if (!config_setattr(current_style, p, l, t))
460 		yyerror("invalid style %s", current_style);
461 }
462 
463 static void
464 add_proxy(char *proto, char *proxy)
465 {
466 	struct proxy *p;
467 	struct phos_uri uri;
468 
469 	if (!phos_parse_absolute_uri(proxy, &uri)) {
470 		yyerror("can't parse URL: %s", proxy);
471 		return;
472 	}
473 
474 	if (*uri.path != '\0' || *uri.query != '\0' || *uri.fragment != '\0') {
475 		yyerror("proxy url can't have path, query or fragments");
476 		return;
477 	}
478 
479 	if (strcmp(uri.scheme, "gemini")) {
480 		yyerror("disallowed proxy protocol %s", uri.scheme);
481 		return;
482 	}
483 
484 	if ((p = calloc(1, sizeof(*p))) == NULL)
485 		err(1, "calloc");
486 
487 	p->match_proto = proto;
488 	p->proto = PROTO_GEMINI;
489 
490 	if ((p->host = strdup(uri.host)) == NULL)
491 		err(1, "strdup");
492 
493 	if ((p->port = strdup(uri.port)) == NULL)
494 		err(1, "strdup");
495 
496 	TAILQ_INSERT_HEAD(&proxies, p, proxies);
497 }
498 
499 static interactivefn *
500 cmdname(const char *name)
501 {
502 	struct cmd *cmd;
503 
504 	for (cmd = cmds; cmd->cmd != NULL; ++cmd) {
505 		if (!strcmp(cmd->cmd, name))
506 			return cmd->fn;
507 	}
508 
509 	return NULL;
510 }
511 
512 static void
513 bindkey(const char *map, const char *key, const char *cmd)
514 {
515 	struct kmap *kmap;
516 	interactivefn *fn;
517 
518 	if (!strcmp(map, "global-map"))
519 		kmap = &global_map;
520 	else if (!strcmp(map, "minibuffer-map"))
521 		kmap = &minibuffer_map;
522 	else {
523 		yyerror("unknown map: %s", map);
524 		return;
525 	}
526 
527 	if ((fn = cmdname(cmd)) == NULL) {
528 		yyerror("unknown cmd: %s", fn);
529 		return;
530 	}
531 
532 	if (!kmap_define_key(kmap, key, fn))
533 		yyerror("failed to bind %s %s %s", map, key, cmd);
534 }
535 
536 static void
537 do_parseconfig(const char *filename, int fonf)
538 {
539 	if ((yyfp = fopen(filename, "r")) == NULL) {
540 		if (fonf)
541 			err(1, "%s", filename);
542 		return;
543 	}
544 
545 	path = filename;
546 	yyparse();
547 	fclose(yyfp);
548 	if (parse_errors)
549 		exit(1);
550 }
551 
552 void
553 parseconfig(const char *filename, int fonf)
554 {
555 	char altconf[PATH_MAX], *term;
556 
557 	/* load the given config file */
558 	do_parseconfig(filename, fonf);
559 
560 	/* then try to load file-TERM */
561 
562 	if ((term = getenv("TERM")) == NULL)
563 		return;
564 
565 	strlcpy(altconf, filename, sizeof(altconf));
566 	strlcat(altconf, "-", sizeof(altconf));
567 	strlcat(altconf, term, sizeof(altconf));
568 
569 	do_parseconfig(altconf, 0);
570 }