![[BACK]](/icons/back.gif){kind=icon}
Return to cmd-parse.y CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux|
Return to cmd-parse.y CVS log | Up to [local] / src / usr.bin / tmux |
1.46 ! nicm 1: /* $OpenBSD: cmd-parse.y,v 1.45 2021/08/23 11:48:21 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: %{
20:
21: #include <sys/types.h>
22:
23: #include <ctype.h>
24: #include <errno.h>
25: #include <pwd.h>
1.12 nicm 26: #include <stdlib.h>
1.1 nicm 27: #include <string.h>
28: #include <unistd.h>
1.27 nicm 29: #include <wchar.h>
1.1 nicm 30:
31: #include "tmux.h"
32:
33: static int yylex(void);
34: static int yyparse(void);
35: static int printflike(1,2) yyerror(const char *, ...);
36:
37: static char *yylex_token(int);
38: static char *yylex_format(void);
39:
40: struct cmd_parse_scope {
41: int flag;
42: TAILQ_ENTRY (cmd_parse_scope) entry;
43: };
44:
1.33 nicm 45: enum cmd_parse_argument_type {
46: CMD_PARSE_STRING,
1.46 ! nicm 47: CMD_PARSE_COMMANDS,
! 48: CMD_PARSE_PARSED_COMMANDS
1.33 nicm 49: };
50:
51: struct cmd_parse_argument {
52: enum cmd_parse_argument_type type;
53: char *string;
54: struct cmd_parse_commands *commands;
1.46 ! nicm 55: struct cmd_list *cmdlist;
1.33 nicm 56:
57: TAILQ_ENTRY(cmd_parse_argument) entry;
58: };
59: TAILQ_HEAD(cmd_parse_arguments, cmd_parse_argument);
60:
1.1 nicm 61: struct cmd_parse_command {
1.33 nicm 62: u_int line;
63: struct cmd_parse_arguments arguments;
1.1 nicm 64:
1.33 nicm 65: TAILQ_ENTRY(cmd_parse_command) entry;
1.1 nicm 66: };
67: TAILQ_HEAD(cmd_parse_commands, cmd_parse_command);
68:
69: struct cmd_parse_state {
70: FILE *f;
1.5 nicm 71:
72: const char *buf;
73: size_t len;
74: size_t off;
75:
1.15 nicm 76: int condition;
1.8 nicm 77: int eol;
1.1 nicm 78: int eof;
79: struct cmd_parse_input *input;
80: u_int escapes;
81:
82: char *error;
1.13 nicm 83: struct cmd_parse_commands *commands;
1.1 nicm 84:
85: struct cmd_parse_scope *scope;
86: TAILQ_HEAD(, cmd_parse_scope) stack;
87: };
88: static struct cmd_parse_state parse_state;
89:
90: static char *cmd_parse_get_error(const char *, u_int, const char *);
91: static void cmd_parse_free_command(struct cmd_parse_command *);
1.13 nicm 92: static struct cmd_parse_commands *cmd_parse_new_commands(void);
1.1 nicm 93: static void cmd_parse_free_commands(struct cmd_parse_commands *);
1.36 nicm 94: static void cmd_parse_build_commands(struct cmd_parse_commands *,
95: struct cmd_parse_input *, struct cmd_parse_result *);
96: static void cmd_parse_print_commands(struct cmd_parse_input *,
1.14 nicm 97: struct cmd_list *);
1.1 nicm 98:
99: %}
100:
101: %union
102: {
103: char *token;
1.33 nicm 104: struct cmd_parse_arguments *arguments;
105: struct cmd_parse_argument *argument;
1.1 nicm 106: int flag;
107: struct {
108: int flag;
1.13 nicm 109: struct cmd_parse_commands *commands;
1.1 nicm 110: } elif;
1.13 nicm 111: struct cmd_parse_commands *commands;
1.1 nicm 112: struct cmd_parse_command *command;
113: }
114:
115: %token ERROR
1.24 nicm 116: %token HIDDEN
1.1 nicm 117: %token IF
118: %token ELSE
119: %token ELIF
120: %token ENDIF
121: %token <token> FORMAT TOKEN EQUALS
122:
1.33 nicm 123: %type <token> expanded format
1.1 nicm 124: %type <arguments> arguments
1.33 nicm 125: %type <argument> argument
1.1 nicm 126: %type <flag> if_open if_elif
127: %type <elif> elif elif1
1.28 nicm 128: %type <commands> argument_statements statements statement
129: %type <commands> commands condition condition1
1.1 nicm 130: %type <command> command
131:
132: %%
133:
134: lines : /* empty */
135: | statements
136: {
137: struct cmd_parse_state *ps = &parse_state;
138:
1.13 nicm 139: ps->commands = $1;
1.1 nicm 140: }
141:
142: statements : statement '\n'
143: {
1.13 nicm 144: $$ = $1;
1.1 nicm 145: }
146: | statements statement '\n'
147: {
1.13 nicm 148: $$ = $1;
149: TAILQ_CONCAT($$, $2, entry);
150: free($2);
1.1 nicm 151: }
152:
1.22 nicm 153: statement : /* empty */
154: {
155: $$ = xmalloc (sizeof *$$);
156: TAILQ_INIT($$);
157: }
1.24 nicm 158: | hidden_assignment
159: {
160: $$ = xmalloc (sizeof *$$);
161: TAILQ_INIT($$);
162: }
1.22 nicm 163: | condition
1.1 nicm 164: {
165: struct cmd_parse_state *ps = &parse_state;
166:
167: if (ps->scope == NULL || ps->scope->flag)
1.13 nicm 168: $$ = $1;
169: else {
170: $$ = cmd_parse_new_commands();
171: cmd_parse_free_commands($1);
172: }
1.1 nicm 173: }
174: | commands
175: {
176: struct cmd_parse_state *ps = &parse_state;
177:
178: if (ps->scope == NULL || ps->scope->flag)
1.13 nicm 179: $$ = $1;
180: else {
181: $$ = cmd_parse_new_commands();
182: cmd_parse_free_commands($1);
183: }
1.1 nicm 184: }
185:
1.15 nicm 186: format : FORMAT
187: {
188: $$ = $1;
189: }
190: | TOKEN
191: {
192: $$ = $1;
193: }
194:
195: expanded : format
1.1 nicm 196: {
197: struct cmd_parse_state *ps = &parse_state;
198: struct cmd_parse_input *pi = ps->input;
199: struct format_tree *ft;
200: struct client *c = pi->c;
1.18 nicm 201: struct cmd_find_state *fsp;
202: struct cmd_find_state fs;
1.1 nicm 203: int flags = FORMAT_NOJOBS;
204:
205: if (cmd_find_valid_state(&pi->fs))
1.18 nicm 206: fsp = &pi->fs;
207: else {
208: cmd_find_from_client(&fs, c, 0);
209: fsp = &fs;
210: }
1.1 nicm 211: ft = format_create(NULL, pi->item, FORMAT_NONE, flags);
1.18 nicm 212: format_defaults(ft, c, fsp->s, fsp->wl, fsp->wp);
1.1 nicm 213:
214: $$ = format_expand(ft, $1);
215: format_free(ft);
216: free($1);
217: }
218:
1.22 nicm 219: optional_assignment : /* empty */
220: | assignment
221:
222: assignment : EQUALS
1.1 nicm 223: {
224: struct cmd_parse_state *ps = &parse_state;
225: int flags = ps->input->flags;
226:
227: if ((~flags & CMD_PARSE_PARSEONLY) &&
228: (ps->scope == NULL || ps->scope->flag))
1.24 nicm 229: environ_put(global_environ, $1, 0);
1.1 nicm 230: free($1);
231: }
232:
1.24 nicm 233: hidden_assignment : HIDDEN EQUALS
234: {
235: struct cmd_parse_state *ps = &parse_state;
236: int flags = ps->input->flags;
237:
238: if ((~flags & CMD_PARSE_PARSEONLY) &&
239: (ps->scope == NULL || ps->scope->flag))
240: environ_put(global_environ, $2, ENVIRON_HIDDEN);
241: free($2);
242: }
243:
1.1 nicm 244: if_open : IF expanded
245: {
246: struct cmd_parse_state *ps = &parse_state;
247: struct cmd_parse_scope *scope;
248:
249: scope = xmalloc(sizeof *scope);
250: $$ = scope->flag = format_true($2);
251: free($2);
252:
253: if (ps->scope != NULL)
254: TAILQ_INSERT_HEAD(&ps->stack, ps->scope, entry);
255: ps->scope = scope;
256: }
257:
258: if_else : ELSE
259: {
260: struct cmd_parse_state *ps = &parse_state;
261: struct cmd_parse_scope *scope;
262:
263: scope = xmalloc(sizeof *scope);
264: scope->flag = !ps->scope->flag;
265:
266: free(ps->scope);
267: ps->scope = scope;
268: }
269:
270: if_elif : ELIF expanded
271: {
272: struct cmd_parse_state *ps = &parse_state;
273: struct cmd_parse_scope *scope;
274:
275: scope = xmalloc(sizeof *scope);
276: $$ = scope->flag = format_true($2);
277: free($2);
278:
279: free(ps->scope);
280: ps->scope = scope;
281: }
282:
283: if_close : ENDIF
284: {
285: struct cmd_parse_state *ps = &parse_state;
286:
287: free(ps->scope);
288: ps->scope = TAILQ_FIRST(&ps->stack);
289: if (ps->scope != NULL)
290: TAILQ_REMOVE(&ps->stack, ps->scope, entry);
291: }
292:
293: condition : if_open '\n' statements if_close
294: {
295: if ($1)
1.13 nicm 296: $$ = $3;
297: else {
298: $$ = cmd_parse_new_commands();
299: cmd_parse_free_commands($3);
300: }
1.1 nicm 301: }
302: | if_open '\n' statements if_else '\n' statements if_close
303: {
304: if ($1) {
1.13 nicm 305: $$ = $3;
306: cmd_parse_free_commands($6);
1.1 nicm 307: } else {
1.13 nicm 308: $$ = $6;
309: cmd_parse_free_commands($3);
1.1 nicm 310: }
311: }
312: | if_open '\n' statements elif if_close
313: {
314: if ($1) {
1.13 nicm 315: $$ = $3;
316: cmd_parse_free_commands($4.commands);
1.1 nicm 317: } else if ($4.flag) {
1.13 nicm 318: $$ = $4.commands;
319: cmd_parse_free_commands($3);
1.1 nicm 320: } else {
1.13 nicm 321: $$ = cmd_parse_new_commands();
322: cmd_parse_free_commands($3);
323: cmd_parse_free_commands($4.commands);
1.1 nicm 324: }
325: }
326: | if_open '\n' statements elif if_else '\n' statements if_close
327: {
328: if ($1) {
1.13 nicm 329: $$ = $3;
330: cmd_parse_free_commands($4.commands);
331: cmd_parse_free_commands($7);
1.1 nicm 332: } else if ($4.flag) {
1.13 nicm 333: $$ = $4.commands;
334: cmd_parse_free_commands($3);
335: cmd_parse_free_commands($7);
336: } else {
337: $$ = $7;
338: cmd_parse_free_commands($3);
339: cmd_parse_free_commands($4.commands);
1.1 nicm 340: }
341: }
342:
343: elif : if_elif '\n' statements
344: {
1.13 nicm 345: if ($1) {
346: $$.flag = 1;
347: $$.commands = $3;
348: } else {
349: $$.flag = 0;
350: $$.commands = cmd_parse_new_commands();
351: cmd_parse_free_commands($3);
352: }
1.1 nicm 353: }
354: | if_elif '\n' statements elif
355: {
356: if ($1) {
357: $$.flag = 1;
1.13 nicm 358: $$.commands = $3;
359: cmd_parse_free_commands($4.commands);
360: } else if ($4.flag) {
361: $$.flag = 1;
362: $$.commands = $4.commands;
363: cmd_parse_free_commands($3);
1.1 nicm 364: } else {
1.13 nicm 365: $$.flag = 0;
366: $$.commands = cmd_parse_new_commands();
367: cmd_parse_free_commands($3);
368: cmd_parse_free_commands($4.commands);
1.1 nicm 369: }
370: }
371:
372: commands : command
373: {
374: struct cmd_parse_state *ps = &parse_state;
375:
1.13 nicm 376: $$ = cmd_parse_new_commands();
1.33 nicm 377: if (!TAILQ_EMPTY(&$1->arguments) &&
1.23 nicm 378: (ps->scope == NULL || ps->scope->flag))
1.13 nicm 379: TAILQ_INSERT_TAIL($$, $1, entry);
1.1 nicm 380: else
381: cmd_parse_free_command($1);
382: }
383: | commands ';'
384: {
1.13 nicm 385: $$ = $1;
1.1 nicm 386: }
387: | commands ';' condition1
388: {
1.13 nicm 389: $$ = $1;
390: TAILQ_CONCAT($$, $3, entry);
391: free($3);
1.1 nicm 392: }
393: | commands ';' command
394: {
395: struct cmd_parse_state *ps = &parse_state;
396:
1.33 nicm 397: if (!TAILQ_EMPTY(&$3->arguments) &&
1.23 nicm 398: (ps->scope == NULL || ps->scope->flag)) {
1.13 nicm 399: $$ = $1;
400: TAILQ_INSERT_TAIL($$, $3, entry);
1.1 nicm 401: } else {
1.13 nicm 402: $$ = cmd_parse_new_commands();
403: cmd_parse_free_commands($1);
1.1 nicm 404: cmd_parse_free_command($3);
405: }
406: }
407: | condition1
408: {
1.13 nicm 409: $$ = $1;
1.1 nicm 410: }
411:
1.22 nicm 412: command : assignment
413: {
414: struct cmd_parse_state *ps = &parse_state;
415:
416: $$ = xcalloc(1, sizeof *$$);
417: $$->line = ps->input->line;
1.33 nicm 418: TAILQ_INIT(&$$->arguments);
1.22 nicm 419: }
420: | optional_assignment TOKEN
1.1 nicm 421: {
1.33 nicm 422: struct cmd_parse_state *ps = &parse_state;
423: struct cmd_parse_argument *arg;
1.1 nicm 424:
425: $$ = xcalloc(1, sizeof *$$);
1.10 nicm 426: $$->line = ps->input->line;
1.33 nicm 427: TAILQ_INIT(&$$->arguments);
1.1 nicm 428:
1.33 nicm 429: arg = xcalloc(1, sizeof *arg);
430: arg->type = CMD_PARSE_STRING;
1.43 nicm 431: arg->string = $2;
1.33 nicm 432: TAILQ_INSERT_HEAD(&$$->arguments, arg, entry);
1.1 nicm 433: }
1.22 nicm 434: | optional_assignment TOKEN arguments
1.1 nicm 435: {
1.33 nicm 436: struct cmd_parse_state *ps = &parse_state;
437: struct cmd_parse_argument *arg;
1.1 nicm 438:
439: $$ = xcalloc(1, sizeof *$$);
1.10 nicm 440: $$->line = ps->input->line;
1.33 nicm 441: TAILQ_INIT(&$$->arguments);
442:
443: TAILQ_CONCAT(&$$->arguments, $3, entry);
444: free($3);
1.1 nicm 445:
1.33 nicm 446: arg = xcalloc(1, sizeof *arg);
447: arg->type = CMD_PARSE_STRING;
1.43 nicm 448: arg->string = $2;
1.33 nicm 449: TAILQ_INSERT_HEAD(&$$->arguments, arg, entry);
1.1 nicm 450: }
451:
452: condition1 : if_open commands if_close
453: {
454: if ($1)
1.13 nicm 455: $$ = $2;
456: else {
457: $$ = cmd_parse_new_commands();
458: cmd_parse_free_commands($2);
459: }
1.1 nicm 460: }
461: | if_open commands if_else commands if_close
462: {
463: if ($1) {
1.13 nicm 464: $$ = $2;
465: cmd_parse_free_commands($4);
1.1 nicm 466: } else {
1.13 nicm 467: $$ = $4;
468: cmd_parse_free_commands($2);
1.1 nicm 469: }
470: }
471: | if_open commands elif1 if_close
472: {
473: if ($1) {
1.13 nicm 474: $$ = $2;
475: cmd_parse_free_commands($3.commands);
1.1 nicm 476: } else if ($3.flag) {
1.13 nicm 477: $$ = $3.commands;
478: cmd_parse_free_commands($2);
1.1 nicm 479: } else {
1.13 nicm 480: $$ = cmd_parse_new_commands();
481: cmd_parse_free_commands($2);
482: cmd_parse_free_commands($3.commands);
1.1 nicm 483: }
484: }
485: | if_open commands elif1 if_else commands if_close
486: {
487: if ($1) {
1.13 nicm 488: $$ = $2;
489: cmd_parse_free_commands($3.commands);
490: cmd_parse_free_commands($5);
1.1 nicm 491: } else if ($3.flag) {
1.13 nicm 492: $$ = $3.commands;
493: cmd_parse_free_commands($2);
494: cmd_parse_free_commands($5);
495: } else {
496: $$ = $5;
497: cmd_parse_free_commands($2);
498: cmd_parse_free_commands($3.commands);
1.1 nicm 499: }
500: }
501:
502: elif1 : if_elif commands
503: {
1.13 nicm 504: if ($1) {
505: $$.flag = 1;
506: $$.commands = $2;
507: } else {
508: $$.flag = 0;
509: $$.commands = cmd_parse_new_commands();
510: cmd_parse_free_commands($2);
511: }
1.1 nicm 512: }
513: | if_elif commands elif1
514: {
515: if ($1) {
516: $$.flag = 1;
1.13 nicm 517: $$.commands = $2;
518: cmd_parse_free_commands($3.commands);
519: } else if ($3.flag) {
520: $$.flag = 1;
521: $$.commands = $3.commands;
522: cmd_parse_free_commands($2);
1.1 nicm 523: } else {
1.13 nicm 524: $$.flag = 0;
525: $$.commands = cmd_parse_new_commands();
526: cmd_parse_free_commands($2);
527: cmd_parse_free_commands($3.commands);
1.1 nicm 528: }
529: }
530:
531: arguments : argument
532: {
1.33 nicm 533: $$ = xcalloc(1, sizeof *$$);
534: TAILQ_INIT($$);
1.1 nicm 535:
1.33 nicm 536: TAILQ_INSERT_HEAD($$, $1, entry);
1.1 nicm 537: }
538: | argument arguments
539: {
1.33 nicm 540: TAILQ_INSERT_HEAD($2, $1, entry);
1.1 nicm 541: $$ = $2;
542: }
543:
544: argument : TOKEN
545: {
1.33 nicm 546: $$ = xcalloc(1, sizeof *$$);
547: $$->type = CMD_PARSE_STRING;
1.43 nicm 548: $$->string = $1;
1.1 nicm 549: }
550: | EQUALS
551: {
1.33 nicm 552: $$ = xcalloc(1, sizeof *$$);
553: $$->type = CMD_PARSE_STRING;
1.43 nicm 554: $$->string = $1;
1.1 nicm 555: }
1.28 nicm 556: | '{' argument_statements
557: {
1.33 nicm 558: $$ = xcalloc(1, sizeof *$$);
559: $$->type = CMD_PARSE_COMMANDS;
560: $$->commands = $2;
1.28 nicm 561: }
562:
563: argument_statements : statement '}'
564: {
565: $$ = $1;
566: }
1.30 nicm 567: | statements statement '}'
1.28 nicm 568: {
569: $$ = $1;
1.30 nicm 570: TAILQ_CONCAT($$, $2, entry);
571: free($2);
1.28 nicm 572: }
1.1 nicm 573:
574: %%
575:
576: static char *
577: cmd_parse_get_error(const char *file, u_int line, const char *error)
578: {
579: char *s;
580:
581: if (file == NULL)
582: s = xstrdup(error);
583: else
1.37 nicm 584: xasprintf(&s, "%s:%u: %s", file, line, error);
1.1 nicm 585: return (s);
586: }
587:
588: static void
1.36 nicm 589: cmd_parse_print_commands(struct cmd_parse_input *pi, struct cmd_list *cmdlist)
1.14 nicm 590: {
591: char *s;
592:
1.36 nicm 593: if (pi->item == NULL || (~pi->flags & CMD_PARSE_VERBOSE))
594: return;
595: s = cmd_list_print(cmdlist, 0);
596: if (pi->file != NULL)
597: cmdq_print(pi->item, "%s:%u: %s", pi->file, pi->line, s);
598: else
599: cmdq_print(pi->item, "%u: %s", pi->line, s);
600: free(s);
601: }
602:
603: static void
604: cmd_parse_free_argument(struct cmd_parse_argument *arg)
605: {
606: switch (arg->type) {
607: case CMD_PARSE_STRING:
608: free(arg->string);
609: break;
610: case CMD_PARSE_COMMANDS:
611: cmd_parse_free_commands(arg->commands);
612: break;
1.46 ! nicm 613: case CMD_PARSE_PARSED_COMMANDS:
! 614: cmd_list_free(arg->cmdlist);
! 615: break;
1.14 nicm 616: }
1.36 nicm 617: free(arg);
1.14 nicm 618: }
619:
620: static void
1.33 nicm 621: cmd_parse_free_arguments(struct cmd_parse_arguments *args)
622: {
623: struct cmd_parse_argument *arg, *arg1;
624:
625: TAILQ_FOREACH_SAFE(arg, args, entry, arg1) {
626: TAILQ_REMOVE(args, arg, entry);
1.36 nicm 627: cmd_parse_free_argument(arg);
1.33 nicm 628: }
629: }
630:
631: static void
1.1 nicm 632: cmd_parse_free_command(struct cmd_parse_command *cmd)
633: {
1.33 nicm 634: cmd_parse_free_arguments(&cmd->arguments);
1.1 nicm 635: free(cmd);
636: }
637:
1.13 nicm 638: static struct cmd_parse_commands *
639: cmd_parse_new_commands(void)
640: {
641: struct cmd_parse_commands *cmds;
642:
643: cmds = xmalloc(sizeof *cmds);
1.33 nicm 644: TAILQ_INIT(cmds);
1.13 nicm 645: return (cmds);
646: }
647:
1.1 nicm 648: static void
649: cmd_parse_free_commands(struct cmd_parse_commands *cmds)
650: {
651: struct cmd_parse_command *cmd, *cmd1;
652:
653: TAILQ_FOREACH_SAFE(cmd, cmds, entry, cmd1) {
654: TAILQ_REMOVE(cmds, cmd, entry);
655: cmd_parse_free_command(cmd);
656: }
1.13 nicm 657: free(cmds);
1.1 nicm 658: }
659:
660: static struct cmd_parse_commands *
1.5 nicm 661: cmd_parse_run_parser(char **cause)
1.1 nicm 662: {
1.13 nicm 663: struct cmd_parse_state *ps = &parse_state;
664: struct cmd_parse_scope *scope, *scope1;
665: int retval;
1.1 nicm 666:
1.13 nicm 667: ps->commands = NULL;
1.1 nicm 668: TAILQ_INIT(&ps->stack);
669:
670: retval = yyparse();
671: TAILQ_FOREACH_SAFE(scope, &ps->stack, entry, scope1) {
672: TAILQ_REMOVE(&ps->stack, scope, entry);
673: free(scope);
674: }
675: if (retval != 0) {
676: *cause = ps->error;
677: return (NULL);
678: }
679:
1.13 nicm 680: if (ps->commands == NULL)
681: return (cmd_parse_new_commands());
682: return (ps->commands);
1.1 nicm 683: }
684:
1.5 nicm 685: static struct cmd_parse_commands *
686: cmd_parse_do_file(FILE *f, struct cmd_parse_input *pi, char **cause)
687: {
688: struct cmd_parse_state *ps = &parse_state;
689:
690: memset(ps, 0, sizeof *ps);
691: ps->input = pi;
692: ps->f = f;
693: return (cmd_parse_run_parser(cause));
694: }
695:
696: static struct cmd_parse_commands *
697: cmd_parse_do_buffer(const char *buf, size_t len, struct cmd_parse_input *pi,
698: char **cause)
699: {
700: struct cmd_parse_state *ps = &parse_state;
701:
702: memset(ps, 0, sizeof *ps);
703: ps->input = pi;
704: ps->buf = buf;
705: ps->len = len;
706: return (cmd_parse_run_parser(cause));
707: }
708:
1.33 nicm 709: static void
710: cmd_parse_log_commands(struct cmd_parse_commands *cmds, const char *prefix)
711: {
712: struct cmd_parse_command *cmd;
713: struct cmd_parse_argument *arg;
714: u_int i, j;
715: char *s;
716:
717: i = 0;
718: TAILQ_FOREACH(cmd, cmds, entry) {
719: j = 0;
720: TAILQ_FOREACH(arg, &cmd->arguments, entry) {
721: switch (arg->type) {
722: case CMD_PARSE_STRING:
723: log_debug("%s %u:%u: %s", prefix, i, j,
724: arg->string);
725: break;
726: case CMD_PARSE_COMMANDS:
727: xasprintf(&s, "%s %u:%u", prefix, i, j);
728: cmd_parse_log_commands(arg->commands, s);
729: free(s);
730: break;
1.46 ! nicm 731: case CMD_PARSE_PARSED_COMMANDS:
! 732: s = cmd_list_print(arg->cmdlist, 0);
! 733: log_debug("%s %u:%u: %s", prefix, i, j, s);
! 734: free(s);
! 735: break;
1.33 nicm 736: }
737: j++;
738: }
739: i++;
740: }
741: }
742:
1.36 nicm 743: static int
744: cmd_parse_expand_alias(struct cmd_parse_command *cmd,
745: struct cmd_parse_input *pi, struct cmd_parse_result *pr,
746: struct cmd_list **cmdlist)
1.33 nicm 747: {
1.36 nicm 748: struct cmd_parse_argument *arg, *arg1, *first, *after;
749: struct cmd_parse_commands *cmds;
750: struct cmd_parse_command *last;
751: char *alias, *name, *cause;
752:
753: *cmdlist = NULL;
1.33 nicm 754:
1.36 nicm 755: first = TAILQ_FIRST(&cmd->arguments);
756: if (first == NULL || first->type != CMD_PARSE_STRING) {
1.39 nicm 757: pr->status = CMD_PARSE_SUCCESS;
758: pr->cmdlist = cmd_list_new();
1.36 nicm 759: return (1);
760: }
761: name = first->string;
762:
763: alias = cmd_get_alias(name);
764: if (alias == NULL)
765: return (0);
766: log_debug("%s: %u alias %s = %s", __func__, pi->line, name, alias);
767:
768: cmds = cmd_parse_do_buffer(alias, strlen(alias), pi, &cause);
769: free(alias);
770: if (cmds == NULL) {
771: pr->status = CMD_PARSE_ERROR;
772: pr->error = cause;
773: return (1);
774: }
775:
776: last = TAILQ_LAST(cmds, cmd_parse_commands);
777: if (last == NULL) {
778: *cmdlist = cmd_list_new();
779: return (1);
780: }
781:
782: TAILQ_REMOVE(&cmd->arguments, first, entry);
783: cmd_parse_free_argument(first);
784:
1.42 nicm 785: after = TAILQ_FIRST(&last->arguments);
1.36 nicm 786: TAILQ_FOREACH_SAFE(arg, &cmd->arguments, entry, arg1) {
787: TAILQ_REMOVE(&cmd->arguments, arg, entry);
788: if (after == NULL)
789: TAILQ_INSERT_TAIL(&last->arguments, arg, entry);
790: else
791: TAILQ_INSERT_AFTER(&last->arguments, after, arg, entry);
792: after = arg;
793: }
794: cmd_parse_log_commands(cmds, __func__);
1.33 nicm 795:
1.36 nicm 796: cmd_parse_build_commands(cmds, pi, pr);
797: if (pr->status != CMD_PARSE_SUCCESS)
798: *cmdlist = pr->cmdlist;
799: return (1);
1.33 nicm 800: }
801:
1.36 nicm 802: static struct cmd_list *
803: cmd_parse_build_command(struct cmd_parse_command *cmd,
804: struct cmd_parse_input *pi, struct cmd_parse_result *pr)
1.33 nicm 805: {
806: struct cmd_parse_argument *arg;
1.40 nicm 807: struct cmd_list *cmdlist = NULL;
1.36 nicm 808: struct cmd *add;
1.40 nicm 809: char *cause;
810: struct args_value *values = NULL;
811: u_int count = 0, idx;
1.33 nicm 812:
1.36 nicm 813: if (cmd_parse_expand_alias(cmd, pi, pr, &cmdlist))
814: return (cmdlist);
1.33 nicm 815:
816: TAILQ_FOREACH(arg, &cmd->arguments, entry) {
1.41 nicm 817: values = xrecallocarray(values, count, count + 1,
818: sizeof *values);
1.33 nicm 819: switch (arg->type) {
820: case CMD_PARSE_STRING:
1.40 nicm 821: values[count].type = ARGS_STRING;
822: values[count].string = xstrdup(arg->string);
1.33 nicm 823: break;
824: case CMD_PARSE_COMMANDS:
1.36 nicm 825: cmd_parse_build_commands(arg->commands, pi, pr);
826: if (pr->status != CMD_PARSE_SUCCESS)
1.40 nicm 827: goto out;
828: values[count].type = ARGS_COMMANDS;
829: values[count].cmdlist = pr->cmdlist;
1.33 nicm 830: break;
1.46 ! nicm 831: case CMD_PARSE_PARSED_COMMANDS:
! 832: values[count].type = ARGS_COMMANDS;
! 833: values[count].cmdlist = arg->cmdlist;
! 834: values[count].cmdlist->references++;
! 835: break;
1.33 nicm 836: }
1.40 nicm 837: count++;
1.33 nicm 838: }
839:
1.40 nicm 840: add = cmd_parse(values, count, pi->file, pi->line, &cause);
1.35 nicm 841: if (add == NULL) {
842: pr->status = CMD_PARSE_ERROR;
1.36 nicm 843: pr->error = cmd_parse_get_error(pi->file, pi->line, cause);
1.35 nicm 844: free(cause);
1.40 nicm 845: goto out;
1.35 nicm 846: }
1.36 nicm 847: cmdlist = cmd_list_new();
848: cmd_list_append(cmdlist, add);
1.40 nicm 849:
850: out:
851: for (idx = 0; idx < count; idx++)
852: args_free_value(&values[idx]);
853: free(values);
1.36 nicm 854: return (cmdlist);
1.35 nicm 855: }
856:
1.36 nicm 857: static void
1.4 nicm 858: cmd_parse_build_commands(struct cmd_parse_commands *cmds,
1.36 nicm 859: struct cmd_parse_input *pi, struct cmd_parse_result *pr)
1.1 nicm 860: {
1.36 nicm 861: struct cmd_parse_command *cmd;
1.1 nicm 862: u_int line = UINT_MAX;
1.36 nicm 863: struct cmd_list *current = NULL, *result, *add;
864: char *s;
1.1 nicm 865:
1.4 nicm 866: /* Check for an empty list. */
1.1 nicm 867: if (TAILQ_EMPTY(cmds)) {
1.39 nicm 868: pr->status = CMD_PARSE_SUCCESS;
869: pr->cmdlist = cmd_list_new();
1.36 nicm 870: return;
1.1 nicm 871: }
1.36 nicm 872: cmd_parse_log_commands(cmds, __func__);
1.1 nicm 873:
874: /*
875: * Parse each command into a command list. Create a new command list
1.25 nicm 876: * for each line (unless the flag is set) so they get a new group (so
877: * the queue knows which ones to remove if a command fails when
878: * executed).
1.1 nicm 879: */
880: result = cmd_list_new();
881: TAILQ_FOREACH(cmd, cmds, entry) {
1.35 nicm 882: if (((~pi->flags & CMD_PARSE_ONEGROUP) && cmd->line != line)) {
883: if (current != NULL) {
1.36 nicm 884: cmd_parse_print_commands(pi, current);
1.35 nicm 885: cmd_list_move(result, current);
886: cmd_list_free(current);
1.1 nicm 887: }
1.35 nicm 888: current = cmd_list_new();
1.1 nicm 889: }
1.35 nicm 890: if (current == NULL)
891: current = cmd_list_new();
1.36 nicm 892: line = pi->line = cmd->line;
1.1 nicm 893:
1.36 nicm 894: add = cmd_parse_build_command(cmd, pi, pr);
1.1 nicm 895: if (add == NULL) {
896: cmd_list_free(result);
1.35 nicm 897: cmd_list_free(current);
1.36 nicm 898: return;
1.1 nicm 899: }
1.38 nicm 900: cmd_list_append_all(current, add);
1.36 nicm 901: cmd_list_free(add);
1.1 nicm 902: }
1.35 nicm 903: if (current != NULL) {
1.36 nicm 904: cmd_parse_print_commands(pi, current);
1.35 nicm 905: cmd_list_move(result, current);
906: cmd_list_free(current);
1.1 nicm 907: }
908:
1.2 nicm 909: s = cmd_list_print(result, 0);
1.1 nicm 910: log_debug("%s: %s", __func__, s);
911: free(s);
912:
1.36 nicm 913: pr->status = CMD_PARSE_SUCCESS;
914: pr->cmdlist = result;
1.1 nicm 915: }
916:
917: struct cmd_parse_result *
1.4 nicm 918: cmd_parse_from_file(FILE *f, struct cmd_parse_input *pi)
919: {
920: static struct cmd_parse_result pr;
921: struct cmd_parse_input input;
922: struct cmd_parse_commands *cmds;
923: char *cause;
924:
925: if (pi == NULL) {
926: memset(&input, 0, sizeof input);
927: pi = &input;
928: }
929: memset(&pr, 0, sizeof pr);
930:
1.5 nicm 931: cmds = cmd_parse_do_file(f, pi, &cause);
1.4 nicm 932: if (cmds == NULL) {
933: pr.status = CMD_PARSE_ERROR;
934: pr.error = cause;
935: return (&pr);
936: }
1.36 nicm 937: cmd_parse_build_commands(cmds, pi, &pr);
938: cmd_parse_free_commands(cmds);
939: return (&pr);
940:
1.4 nicm 941: }
942:
943: struct cmd_parse_result *
1.1 nicm 944: cmd_parse_from_string(const char *s, struct cmd_parse_input *pi)
945: {
1.25 nicm 946: struct cmd_parse_input input;
947:
948: if (pi == NULL) {
949: memset(&input, 0, sizeof input);
950: pi = &input;
951: }
952:
953: /*
954: * When parsing a string, put commands in one group even if there are
955: * multiple lines. This means { a \n b } is identical to "a ; b" when
956: * given as an argument to another command.
957: */
958: pi->flags |= CMD_PARSE_ONEGROUP;
1.21 nicm 959: return (cmd_parse_from_buffer(s, strlen(s), pi));
1.26 nicm 960: }
961:
962: enum cmd_parse_status
963: cmd_parse_and_insert(const char *s, struct cmd_parse_input *pi,
964: struct cmdq_item *after, struct cmdq_state *state, char **error)
965: {
966: struct cmd_parse_result *pr;
967: struct cmdq_item *item;
968:
969: pr = cmd_parse_from_string(s, pi);
970: switch (pr->status) {
971: case CMD_PARSE_ERROR:
972: if (error != NULL)
973: *error = pr->error;
974: else
975: free(pr->error);
976: break;
977: case CMD_PARSE_SUCCESS:
978: item = cmdq_get_command(pr->cmdlist, state);
979: cmdq_insert_after(after, item);
980: cmd_list_free(pr->cmdlist);
981: break;
982: }
983: return (pr->status);
984: }
985:
986: enum cmd_parse_status
987: cmd_parse_and_append(const char *s, struct cmd_parse_input *pi,
988: struct client *c, struct cmdq_state *state, char **error)
989: {
990: struct cmd_parse_result *pr;
991: struct cmdq_item *item;
992:
993: pr = cmd_parse_from_string(s, pi);
994: switch (pr->status) {
995: case CMD_PARSE_ERROR:
996: if (error != NULL)
997: *error = pr->error;
998: else
999: free(pr->error);
1000: break;
1001: case CMD_PARSE_SUCCESS:
1002: item = cmdq_get_command(pr->cmdlist, state);
1003: cmdq_append(c, item);
1004: cmd_list_free(pr->cmdlist);
1005: break;
1006: }
1007: return (pr->status);
1.21 nicm 1008: }
1009:
1010: struct cmd_parse_result *
1011: cmd_parse_from_buffer(const void *buf, size_t len, struct cmd_parse_input *pi)
1012: {
1.1 nicm 1013: static struct cmd_parse_result pr;
1.4 nicm 1014: struct cmd_parse_input input;
1.5 nicm 1015: struct cmd_parse_commands *cmds;
1016: char *cause;
1.1 nicm 1017:
1.4 nicm 1018: if (pi == NULL) {
1019: memset(&input, 0, sizeof input);
1020: pi = &input;
1021: }
1022: memset(&pr, 0, sizeof pr);
1023:
1.21 nicm 1024: if (len == 0) {
1.39 nicm 1025: pr.status = CMD_PARSE_SUCCESS;
1026: pr.cmdlist = cmd_list_new();
1.1 nicm 1027: return (&pr);
1028: }
1029:
1.21 nicm 1030: cmds = cmd_parse_do_buffer(buf, len, pi, &cause);
1.5 nicm 1031: if (cmds == NULL) {
1.1 nicm 1032: pr.status = CMD_PARSE_ERROR;
1.5 nicm 1033: pr.error = cause;
1034: return (&pr);
1.1 nicm 1035: }
1.36 nicm 1036: cmd_parse_build_commands(cmds, pi, &pr);
1037: cmd_parse_free_commands(cmds);
1038: return (&pr);
1.4 nicm 1039: }
1040:
1.46 ! nicm 1041: struct cmd_parse_result *
! 1042: cmd_parse_from_arguments(struct args_value *values, u_int count,
! 1043: struct cmd_parse_input *pi)
1.33 nicm 1044: {
1.46 ! nicm 1045: static struct cmd_parse_result pr;
! 1046: struct cmd_parse_input input;
! 1047: struct cmd_parse_commands *cmds;
1.33 nicm 1048: struct cmd_parse_command *cmd;
1049: struct cmd_parse_argument *arg;
1.46 ! nicm 1050: u_int i;
! 1051: char *copy;
! 1052: size_t size;
! 1053: int end;
1.4 nicm 1054:
1055: /*
1056: * The commands are already split up into arguments, so just separate
1057: * into a set of commands by ';'.
1058: */
1059:
1060: if (pi == NULL) {
1061: memset(&input, 0, sizeof input);
1062: pi = &input;
1063: }
1064:
1.13 nicm 1065: cmds = cmd_parse_new_commands();
1.4 nicm 1066:
1.46 ! nicm 1067: cmd = xcalloc(1, sizeof *cmd);
! 1068: cmd->line = pi->line;
! 1069: TAILQ_INIT(&cmd->arguments);
! 1070:
! 1071: for (i = 0; i < count; i++) {
! 1072: end = 0;
! 1073: if (values[i].type == ARGS_STRING) {
! 1074: copy = xstrdup(values[i].string);
! 1075: size = strlen(copy);
! 1076: if (size != 0 && copy[size - 1] == ';') {
! 1077: copy[--size] = '\0';
! 1078: if (size > 0 && copy[size - 1] == '\\')
! 1079: copy[size - 1] = ';';
! 1080: else
! 1081: end = 1;
! 1082: }
! 1083: if (!end || size != 0) {
! 1084: arg = xcalloc(1, sizeof *arg);
! 1085: arg->type = CMD_PARSE_STRING;
! 1086: arg->string = copy;
! 1087: TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
! 1088: }
! 1089: } else if (values[i].type == ARGS_COMMANDS) {
! 1090: arg = xcalloc(1, sizeof *arg);
! 1091: arg->type = CMD_PARSE_PARSED_COMMANDS;
! 1092: arg->cmdlist = values[i].cmdlist;
! 1093: arg->cmdlist->references++;
! 1094: TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
! 1095: } else
! 1096: fatalx("unknown argument type");
! 1097: if (end) {
! 1098: TAILQ_INSERT_TAIL(cmds, cmd, entry);
! 1099: cmd = xcalloc(1, sizeof *cmd);
! 1100: cmd->line = pi->line;
! 1101: TAILQ_INIT(&cmd->arguments);
1.4 nicm 1102: }
1103: }
1.46 ! nicm 1104: if (!TAILQ_EMPTY(&cmd->arguments))
! 1105: TAILQ_INSERT_TAIL(cmds, cmd, entry);
! 1106: else
! 1107: free(cmd);
1.13 nicm 1108:
1.36 nicm 1109: cmd_parse_build_commands(cmds, pi, &pr);
1110: cmd_parse_free_commands(cmds);
1111: return (&pr);
1.1 nicm 1112: }
1113:
1114: static int printflike(1, 2)
1115: yyerror(const char *fmt, ...)
1116: {
1117: struct cmd_parse_state *ps = &parse_state;
1118: struct cmd_parse_input *pi = ps->input;
1119: va_list ap;
1120: char *error;
1121:
1122: if (ps->error != NULL)
1123: return (0);
1124:
1125: va_start(ap, fmt);
1126: xvasprintf(&error, fmt, ap);
1127: va_end(ap);
1128:
1129: ps->error = cmd_parse_get_error(pi->file, pi->line, error);
1130: free(error);
1131: return (0);
1132: }
1133:
1134: static int
1135: yylex_is_var(char ch, int first)
1136: {
1137: if (ch == '=')
1138: return (0);
1139: if (first && isdigit((u_char)ch))
1140: return (0);
1141: return (isalnum((u_char)ch) || ch == '_');
1142: }
1143:
1144: static void
1145: yylex_append(char **buf, size_t *len, const char *add, size_t addlen)
1146: {
1147: if (addlen > SIZE_MAX - 1 || *len > SIZE_MAX - 1 - addlen)
1148: fatalx("buffer is too big");
1149: *buf = xrealloc(*buf, (*len) + 1 + addlen);
1150: memcpy((*buf) + *len, add, addlen);
1151: (*len) += addlen;
1152: }
1153:
1154: static void
1155: yylex_append1(char **buf, size_t *len, char add)
1156: {
1157: yylex_append(buf, len, &add, 1);
1158: }
1159:
1160: static int
1.5 nicm 1161: yylex_getc1(void)
1162: {
1163: struct cmd_parse_state *ps = &parse_state;
1164: int ch;
1165:
1166: if (ps->f != NULL)
1167: ch = getc(ps->f);
1168: else {
1169: if (ps->off == ps->len)
1170: ch = EOF;
1171: else
1172: ch = ps->buf[ps->off++];
1173: }
1174: return (ch);
1175: }
1176:
1177: static void
1178: yylex_ungetc(int ch)
1179: {
1180: struct cmd_parse_state *ps = &parse_state;
1181:
1182: if (ps->f != NULL)
1183: ungetc(ch, ps->f);
1184: else if (ps->off > 0 && ch != EOF)
1185: ps->off--;
1186: }
1187:
1188: static int
1.1 nicm 1189: yylex_getc(void)
1190: {
1191: struct cmd_parse_state *ps = &parse_state;
1192: int ch;
1193:
1194: if (ps->escapes != 0) {
1195: ps->escapes--;
1196: return ('\\');
1197: }
1198: for (;;) {
1.5 nicm 1199: ch = yylex_getc1();
1.1 nicm 1200: if (ch == '\\') {
1201: ps->escapes++;
1202: continue;
1203: }
1204: if (ch == '\n' && (ps->escapes % 2) == 1) {
1205: ps->input->line++;
1206: ps->escapes--;
1207: continue;
1208: }
1209:
1210: if (ps->escapes != 0) {
1.5 nicm 1211: yylex_ungetc(ch);
1.1 nicm 1212: ps->escapes--;
1213: return ('\\');
1214: }
1215: return (ch);
1216: }
1217: }
1218:
1219: static char *
1220: yylex_get_word(int ch)
1221: {
1.5 nicm 1222: char *buf;
1223: size_t len;
1.1 nicm 1224:
1225: len = 0;
1226: buf = xmalloc(1);
1227:
1228: do
1229: yylex_append1(&buf, &len, ch);
1230: while ((ch = yylex_getc()) != EOF && strchr(" \t\n", ch) == NULL);
1.5 nicm 1231: yylex_ungetc(ch);
1.1 nicm 1232:
1233: buf[len] = '\0';
1234: log_debug("%s: %s", __func__, buf);
1235: return (buf);
1236: }
1237:
1238: static int
1239: yylex(void)
1240: {
1241: struct cmd_parse_state *ps = &parse_state;
1242: char *token, *cp;
1.15 nicm 1243: int ch, next, condition;
1.1 nicm 1244:
1.8 nicm 1245: if (ps->eol)
1246: ps->input->line++;
1247: ps->eol = 0;
1248:
1.15 nicm 1249: condition = ps->condition;
1250: ps->condition = 0;
1251:
1.1 nicm 1252: for (;;) {
1253: ch = yylex_getc();
1254:
1255: if (ch == EOF) {
1256: /*
1257: * Ensure every file or string is terminated by a
1258: * newline. This keeps the parser simpler and avoids
1259: * having to add a newline to each string.
1260: */
1261: if (ps->eof)
1262: break;
1263: ps->eof = 1;
1264: return ('\n');
1265: }
1266:
1267: if (ch == ' ' || ch == '\t') {
1268: /*
1269: * Ignore whitespace.
1270: */
1271: continue;
1272: }
1273:
1274: if (ch == '\n') {
1275: /*
1276: * End of line. Update the line number.
1277: */
1.8 nicm 1278: ps->eol = 1;
1.1 nicm 1279: return ('\n');
1280: }
1281:
1.28 nicm 1282: if (ch == ';' || ch == '{' || ch == '}') {
1.1 nicm 1283: /*
1.28 nicm 1284: * A semicolon or { or } is itself.
1.1 nicm 1285: */
1.28 nicm 1286: return (ch);
1.1 nicm 1287: }
1288:
1289: if (ch == '#') {
1290: /*
1.15 nicm 1291: * #{ after a condition opens a format; anything else
1292: * is a comment, ignore up to the end of the line.
1.1 nicm 1293: */
1294: next = yylex_getc();
1.15 nicm 1295: if (condition && next == '{') {
1.1 nicm 1296: yylval.token = yylex_format();
1297: if (yylval.token == NULL)
1298: return (ERROR);
1299: return (FORMAT);
1300: }
1301: while (next != '\n' && next != EOF)
1302: next = yylex_getc();
1303: if (next == '\n') {
1304: ps->input->line++;
1305: return ('\n');
1306: }
1307: continue;
1308: }
1309:
1310: if (ch == '%') {
1311: /*
1.11 nicm 1312: * % is a condition unless it is all % or all numbers,
1313: * then it is a token.
1.1 nicm 1314: */
1315: yylval.token = yylex_get_word('%');
1.11 nicm 1316: for (cp = yylval.token; *cp != '\0'; cp++) {
1317: if (*cp != '%' && !isdigit((u_char)*cp))
1318: break;
1319: }
1320: if (*cp == '\0')
1.1 nicm 1321: return (TOKEN);
1.15 nicm 1322: ps->condition = 1;
1.24 nicm 1323: if (strcmp(yylval.token, "%hidden") == 0) {
1324: free(yylval.token);
1325: return (HIDDEN);
1326: }
1.1 nicm 1327: if (strcmp(yylval.token, "%if") == 0) {
1328: free(yylval.token);
1329: return (IF);
1330: }
1331: if (strcmp(yylval.token, "%else") == 0) {
1332: free(yylval.token);
1333: return (ELSE);
1334: }
1335: if (strcmp(yylval.token, "%elif") == 0) {
1336: free(yylval.token);
1337: return (ELIF);
1338: }
1339: if (strcmp(yylval.token, "%endif") == 0) {
1340: free(yylval.token);
1341: return (ENDIF);
1342: }
1343: free(yylval.token);
1344: return (ERROR);
1345: }
1346:
1347: /*
1348: * Otherwise this is a token.
1349: */
1350: token = yylex_token(ch);
1351: if (token == NULL)
1352: return (ERROR);
1353: yylval.token = token;
1354:
1355: if (strchr(token, '=') != NULL && yylex_is_var(*token, 1)) {
1356: for (cp = token + 1; *cp != '='; cp++) {
1357: if (!yylex_is_var(*cp, 0))
1358: break;
1359: }
1360: if (*cp == '=')
1361: return (EQUALS);
1362: }
1363: return (TOKEN);
1364: }
1365: return (0);
1366: }
1367:
1368: static char *
1369: yylex_format(void)
1370: {
1371: char *buf;
1372: size_t len;
1373: int ch, brackets = 1;
1374:
1375: len = 0;
1376: buf = xmalloc(1);
1377:
1378: yylex_append(&buf, &len, "#{", 2);
1379: for (;;) {
1380: if ((ch = yylex_getc()) == EOF || ch == '\n')
1381: goto error;
1382: if (ch == '#') {
1383: if ((ch = yylex_getc()) == EOF || ch == '\n')
1384: goto error;
1385: if (ch == '{')
1386: brackets++;
1387: yylex_append1(&buf, &len, '#');
1388: } else if (ch == '}') {
1389: if (brackets != 0 && --brackets == 0) {
1390: yylex_append1(&buf, &len, ch);
1391: break;
1392: }
1393: }
1394: yylex_append1(&buf, &len, ch);
1395: }
1396: if (brackets != 0)
1397: goto error;
1398:
1399: buf[len] = '\0';
1400: log_debug("%s: %s", __func__, buf);
1401: return (buf);
1402:
1403: error:
1404: free(buf);
1405: return (NULL);
1406: }
1407:
1408: static int
1409: yylex_token_escape(char **buf, size_t *len)
1410: {
1.27 nicm 1411: int ch, type, o2, o3, mlen;
1412: u_int size, i, tmp;
1413: char s[9], m[MB_LEN_MAX];
1.1 nicm 1414:
1.7 nicm 1415: ch = yylex_getc();
1416:
1417: if (ch >= '4' && ch <= '7') {
1418: yyerror("invalid octal escape");
1419: return (0);
1420: }
1421: if (ch >= '0' && ch <= '3') {
1422: o2 = yylex_getc();
1423: if (o2 >= '0' && o2 <= '7') {
1424: o3 = yylex_getc();
1425: if (o3 >= '0' && o3 <= '7') {
1426: ch = 64 * (ch - '0') +
1427: 8 * (o2 - '0') +
1428: (o3 - '0');
1429: yylex_append1(buf, len, ch);
1430: return (1);
1431: }
1432: }
1433: yyerror("invalid octal escape");
1434: return (0);
1435: }
1436:
1437: switch (ch) {
1.1 nicm 1438: case EOF:
1439: return (0);
1.9 nicm 1440: case 'a':
1441: ch = '\a';
1442: break;
1443: case 'b':
1444: ch = '\b';
1445: break;
1.1 nicm 1446: case 'e':
1447: ch = '\033';
1.9 nicm 1448: break;
1449: case 'f':
1450: ch = '\f';
1451: break;
1452: case 's':
1453: ch = ' ';
1454: break;
1455: case 'v':
1456: ch = '\v';
1.1 nicm 1457: break;
1458: case 'r':
1459: ch = '\r';
1460: break;
1461: case 'n':
1462: ch = '\n';
1463: break;
1464: case 't':
1465: ch = '\t';
1466: break;
1467: case 'u':
1468: type = 'u';
1469: size = 4;
1470: goto unicode;
1471: case 'U':
1472: type = 'U';
1473: size = 8;
1474: goto unicode;
1475: }
1476:
1477: yylex_append1(buf, len, ch);
1478: return (1);
1479:
1480: unicode:
1481: for (i = 0; i < size; i++) {
1482: ch = yylex_getc();
1483: if (ch == EOF || ch == '\n')
1484: return (0);
1485: if (!isxdigit((u_char)ch)) {
1486: yyerror("invalid \\%c argument", type);
1487: return (0);
1488: }
1489: s[i] = ch;
1490: }
1491: s[i] = '\0';
1492:
1493: if ((size == 4 && sscanf(s, "%4x", &tmp) != 1) ||
1494: (size == 8 && sscanf(s, "%8x", &tmp) != 1)) {
1495: yyerror("invalid \\%c argument", type);
1496: return (0);
1497: }
1.27 nicm 1498: mlen = wctomb(m, tmp);
1499: if (mlen <= 0 || mlen > (int)sizeof m) {
1.1 nicm 1500: yyerror("invalid \\%c argument", type);
1501: return (0);
1502: }
1.27 nicm 1503: yylex_append(buf, len, m, mlen);
1.1 nicm 1504: return (1);
1505: }
1506:
1507: static int
1508: yylex_token_variable(char **buf, size_t *len)
1509: {
1510: struct environ_entry *envent;
1511: int ch, brackets = 0;
1.19 nicm 1512: char name[1024];
1.1 nicm 1513: size_t namelen = 0;
1514: const char *value;
1515:
1516: ch = yylex_getc();
1517: if (ch == EOF)
1518: return (0);
1519: if (ch == '{')
1520: brackets = 1;
1521: else {
1522: if (!yylex_is_var(ch, 1)) {
1523: yylex_append1(buf, len, '$');
1.5 nicm 1524: yylex_ungetc(ch);
1.1 nicm 1525: return (1);
1526: }
1527: name[namelen++] = ch;
1528: }
1529:
1530: for (;;) {
1531: ch = yylex_getc();
1532: if (brackets && ch == '}')
1533: break;
1534: if (ch == EOF || !yylex_is_var(ch, 0)) {
1535: if (!brackets) {
1.5 nicm 1536: yylex_ungetc(ch);
1.1 nicm 1537: break;
1538: }
1539: yyerror("invalid environment variable");
1540: return (0);
1541: }
1542: if (namelen == (sizeof name) - 2) {
1543: yyerror("environment variable is too long");
1544: return (0);
1545: }
1546: name[namelen++] = ch;
1547: }
1548: name[namelen] = '\0';
1549:
1550: envent = environ_find(global_environ, name);
1.31 nicm 1551: if (envent != NULL && envent->value != NULL) {
1.1 nicm 1552: value = envent->value;
1553: log_debug("%s: %s -> %s", __func__, name, value);
1554: yylex_append(buf, len, value, strlen(value));
1555: }
1556: return (1);
1557: }
1558:
1559: static int
1560: yylex_token_tilde(char **buf, size_t *len)
1561: {
1562: struct environ_entry *envent;
1563: int ch;
1.19 nicm 1564: char name[1024];
1.1 nicm 1565: size_t namelen = 0;
1566: struct passwd *pw;
1567: const char *home = NULL;
1568:
1569: for (;;) {
1570: ch = yylex_getc();
1571: if (ch == EOF || strchr("/ \t\n\"'", ch) != NULL) {
1.5 nicm 1572: yylex_ungetc(ch);
1.1 nicm 1573: break;
1574: }
1575: if (namelen == (sizeof name) - 2) {
1576: yyerror("user name is too long");
1577: return (0);
1578: }
1579: name[namelen++] = ch;
1580: }
1581: name[namelen] = '\0';
1582:
1583: if (*name == '\0') {
1584: envent = environ_find(global_environ, "HOME");
1585: if (envent != NULL && *envent->value != '\0')
1586: home = envent->value;
1587: else if ((pw = getpwuid(getuid())) != NULL)
1588: home = pw->pw_dir;
1589: } else {
1590: if ((pw = getpwnam(name)) != NULL)
1591: home = pw->pw_dir;
1592: }
1593: if (home == NULL)
1594: return (0);
1595:
1596: log_debug("%s: ~%s -> %s", __func__, name, home);
1597: yylex_append(buf, len, home, strlen(home));
1598: return (1);
1599: }
1600:
1601: static char *
1602: yylex_token(int ch)
1603: {
1604: char *buf;
1605: size_t len;
1606: enum { START,
1607: NONE,
1608: DOUBLE_QUOTES,
1609: SINGLE_QUOTES } state = NONE, last = START;
1610:
1611: len = 0;
1612: buf = xmalloc(1);
1613:
1614: for (;;) {
1.29 nicm 1615: /* EOF or \n are always the end of the token. */
1616: if (ch == EOF || (state == NONE && ch == '\n'))
1.1 nicm 1617: break;
1618:
1.29 nicm 1619: /* Whitespace or ; or } ends a token unless inside quotes. */
1.28 nicm 1620: if ((ch == ' ' || ch == '\t' || ch == ';' || ch == '}') &&
1621: state == NONE)
1.1 nicm 1622: break;
1623:
1.32 nicm 1624: /*
1625: * Spaces and comments inside quotes after \n are removed but
1626: * the \n is left.
1627: */
1.29 nicm 1628: if (ch == '\n' && state != NONE) {
1.32 nicm 1629: yylex_append1(&buf, &len, '\n');
1.29 nicm 1630: while ((ch = yylex_getc()) == ' ' || ch == '\t')
1631: /* nothing */;
1632: if (ch != '#')
1633: continue;
1634: ch = yylex_getc();
1635: if (strchr(",#{}:", ch) != NULL) {
1636: yylex_ungetc(ch);
1637: ch = '#';
1638: } else {
1639: while ((ch = yylex_getc()) != '\n' && ch != EOF)
1640: /* nothing */;
1641: }
1642: continue;
1643: }
1644:
1645: /* \ ~ and $ are expanded except in single quotes. */
1.1 nicm 1646: if (ch == '\\' && state != SINGLE_QUOTES) {
1647: if (!yylex_token_escape(&buf, &len))
1648: goto error;
1649: goto skip;
1650: }
1651: if (ch == '~' && last != state && state != SINGLE_QUOTES) {
1652: if (!yylex_token_tilde(&buf, &len))
1653: goto error;
1654: goto skip;
1655: }
1656: if (ch == '$' && state != SINGLE_QUOTES) {
1657: if (!yylex_token_variable(&buf, &len))
1.6 nicm 1658: goto error;
1659: goto skip;
1660: }
1661: if (ch == '}' && state == NONE)
1662: goto error; /* unmatched (matched ones were handled) */
1.1 nicm 1663:
1.29 nicm 1664: /* ' and " starts or end quotes (and is consumed). */
1.1 nicm 1665: if (ch == '\'') {
1666: if (state == NONE) {
1667: state = SINGLE_QUOTES;
1668: goto next;
1669: }
1670: if (state == SINGLE_QUOTES) {
1671: state = NONE;
1672: goto next;
1673: }
1674: }
1675: if (ch == '"') {
1676: if (state == NONE) {
1677: state = DOUBLE_QUOTES;
1678: goto next;
1679: }
1680: if (state == DOUBLE_QUOTES) {
1681: state = NONE;
1682: goto next;
1683: }
1684: }
1685:
1.29 nicm 1686: /* Otherwise add the character to the buffer. */
1.1 nicm 1687: yylex_append1(&buf, &len, ch);
1688:
1689: skip:
1690: last = state;
1691:
1692: next:
1693: ch = yylex_getc();
1694: }
1.5 nicm 1695: yylex_ungetc(ch);
1.1 nicm 1696:
1697: buf[len] = '\0';
1698: log_debug("%s: %s", __func__, buf);
1699: return (buf);
1700:
1701: error:
1702: free(buf);
1703: return (NULL);
1704: }