1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Command input, lexing and evaluation, resource file loading and `source'ing.
3 *@ TODO PS_ROBOT requires yet PS_SOURCING, which REALLY sucks.
4 *@ TODO Commands and ghosts deserve a hashmap. Or so.
6 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
7 * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
10 * Copyright (c) 1980, 1993
11 * The Regents of the University of California. All rights reserved.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 #define n_FILE lex_input
40 #ifndef HAVE_AMALGAMATION
44 enum a_lex_input_flags
{
46 a_LEX_FREE
= 1<<0, /* Structure was allocated, free() it */
47 a_LEX_PIPE
= 1<<1, /* Open on a pipe */
48 a_LEX_MACRO
= 1<<2, /* Running a macro */
49 a_LEX_MACRO_FREE_DATA
= 1<<3, /* Lines are allocated, free(3) once done */
50 /* TODO For simplicity this is yet _MACRO plus specialization overlay
51 * TODO (_X_OPTION, _CMD) -- these should be types on their own! */
52 a_LEX_MACRO_X_OPTION
= 1<<4, /* Macro indeed command line -X option */
53 a_LEX_MACRO_CMD
= 1<<5, /* Macro indeed single-line: ~:COMMAND */
54 /* TODO a_LEX_SLICE: the right way to support *on-compose-done-shell* would
55 * TODO be a command_loop object that emits an on_read_line event, and
56 * TODO have a special handler for the compose mode; with that, then,
57 * TODO commands_recursive() would not call lex_evaluate() but
58 * TODO CTX->on_read_line, and lex_evaluate() would be the standard impl.,
59 * TODO whereas the COMMAND ESCAPE switch in collect.c would be another one.
60 * TODO With this generic approach accmacvar.c:call_compose_mode_hook()
61 * TODO could be dropped, and n_source_macro() could become extended,
62 * TODO and/or we would add a n_source_anything(), which would allow special
63 * TODO input handlers, special I/O input and output, special `localopts'
64 * TODO etc., to be glued to the new execution context. And all I/O all
65 * TODO over this software should not use stdin/stdout, but CTX->in/out.
66 * TODO The pstate must be a property of the current execution context, too.
67 * TODO This not today. :( For now we invent a special SLICE execution
68 * TODO context overlay that at least allows to temporarily modify the
69 * TODO global pstate, and the global stdin and stdout pointers. HACK!
70 * TODO This slice thing is very special and has to go again. HACK!!
71 * TODO a_lex_input() will drop it once it sees EOF (HACK!), but care for
72 * TODO jumps must be taken by slice creators. HACK!!! But works. ;} */
75 a_LEX_SUPER_MACRO
= 1<<16 /* *Not* inheriting PS_SOURCING state */
79 char const *lc_name
; /* Name of command */
80 int (*lc_func
)(void*); /* Implementor of command */
81 enum argtype lc_argtype
; /* Arglist type (see below) */
82 si16_t lc_msgflag
; /* Required flags of msgs */
83 si16_t lc_msgmask
; /* Relevant flags of msgs */
84 #ifdef HAVE_DOCSTRINGS
85 char const *lc_doc
; /* One line doc for command */
88 /* Yechh, can't initialize unions */
89 #define lc_minargs lc_msgflag /* Minimum argcount for RAWLIST */
90 #define lc_maxargs lc_msgmask /* Max argcount for RAWLIST */
93 struct a_lex_ghost
*lg_next
;
94 struct str lg_cmd
; /* Data follows after .lg_name */
95 char lg_name
[n_VFIELD_SIZE(0)];
98 struct a_lex_eval_ctx
{
99 struct str le_line
; /* The terminated data to _evaluate() */
100 ui32_t le_line_size
; /* May be used to store line memory size */
101 bool_t le_is_recursive
; /* Evaluation in evaluation? (collect ~:) */
103 bool_t le_add_history
; /* Add command to history (TRUM1=gabby)? */
104 char const *le_new_content
; /* History: reenter line, start with this */
107 struct a_lex_input_stack
{
108 struct a_lex_input_stack
*li_outer
;
109 FILE *li_file
; /* File we were in */
110 void *li_cond
; /* Saved state of conditional stack */
111 ui32_t li_flags
; /* enum a_lex_input_flags */
112 ui32_t li_loff
; /* Pseudo (macro): index in .li_lines */
113 char **li_lines
; /* Pseudo content, lines unfolded */
114 void (*li_on_finalize
)(void *);
115 void *li_finalize_arg
;
116 char li_autorecmem
[n_MEMORY_AUTOREC_TYPE_SIZEOF
];
117 sigjmp_buf li_cmdrec_jmp
; /* TODO one day... for command_recursive */
118 /* SLICE hacks: saved stdin/stdout, saved pstate */
119 FILE *li_slice_stdin
;
120 FILE *li_slice_stdout
;
121 ui32_t li_slice_options
;
122 ui8_t li_slice__dummy
[4];
123 char li_name
[n_VFIELD_SIZE(0)]; /* Name of file or macro */
125 n_CTA(n_MEMORY_AUTOREC_TYPE_SIZEOF
% sizeof(void*) == 0,
126 "Inacceptible size of structure buffer");
128 static sighandler_type a_lex_oldpipe
;
129 static struct a_lex_ghost
*a_lex_ghosts
;
130 /* a_lex_cmd_tab[] after fun protos */
133 static struct a_lex_input_stack
*a_lex_input
;
135 static sigjmp_buf a_lex_srbuf
; /* TODO GET RID */
137 /* Isolate the command from the arguments */
138 static char *a_lex_isolate(char const *comm
);
140 /* Command ghost handling */
141 static int a_lex_c_ghost(void *v
);
142 static int a_lex_c_unghost(void *v
);
145 static char const *a_lex_cmdinfo(struct a_lex_cmd
const *lcp
);
147 /* Print a list of all commands */
148 static int a_lex_c_list(void *v
);
150 static int a_lex__pcmd_cmp(void const *s1
, void const *s2
);
152 /* `help' / `?' command */
153 static int a_lex_c_help(void *v
);
155 /* `exit' and `quit' commands */
156 static int a_lex_c_exit(void *v
);
157 static int a_lex_c_quit(void *v
);
159 /* Print the binaries version number */
160 static int a_lex_c_version(void *v
);
162 static int a_lex__version_cmp(void const *s1
, void const *s2
);
164 /* PS_STATE_PENDMASK requires some actions */
165 static void a_lex_update_pstate(void);
167 /* Evaluate a single command.
168 * .le_add_history and .le_new_content will be updated upon success.
169 * Command functions return 0 for success, 1 for error, and -1 for abort.
170 * 1 or -1 aborts a load or source, a -1 aborts the interactive command loop */
171 static int a_lex_evaluate(struct a_lex_eval_ctx
*evp
);
173 /* Get first-fit, or NULL */
174 static struct a_lex_cmd
const *a_lex__firstfit(char const *comm
);
176 /* Branch here on hangup signal and simulate "exit" */
177 static void a_lex_hangup(int s
);
179 /* The following gets called on receipt of an interrupt. Close all open files
180 * except 0, 1, 2, and the temporary. Also, unstack all source files */
181 static void a_lex_onintr(int s
);
183 /* Pop the current input back to the previous level. Update the program state.
184 * If the argument is TRUM1 then we don't alert and error out if the stack
185 * doesn't exist at all */
186 static void a_lex_unstack(bool_t eval_error
);
188 /* `source' and `source_if' (if silent_error: no pipes allowed, then) */
189 static bool_t
a_lex_source_file(char const *file
, bool_t silent_error
);
191 /* System resource file load()ing or -X command line option array traversal */
192 static bool_t
a_lex_load(struct a_lex_input_stack
*lip
);
194 /* A simplified command loop for recursed state machines */
195 static bool_t
a_commands_recursive(enum n_lexinput_flags lif
);
197 /* List of all commands, and list of commands which are specially treated
198 * and deduced in _evaluate(), but we need a list for _c_list() and
199 * print_comm_docstr() */
200 #ifdef HAVE_DOCSTRINGS
205 static struct a_lex_cmd
const a_lex_cmd_tab
[] = {
208 a_lex_special_cmd_tab
[] = {
210 DS(N_("Comment command: ignore remaining (continuable) line")) },
212 DS(N_("Print out the preceding message")) }
217 a_lex_isolate(char const *comm
){
219 while(*comm
!= '\0' &&
220 strchr("~|? \t0123456789&%@$^.:/-+*'\",;(`", *comm
) == NULL
)
223 return n_UNCONST(comm
);
227 a_lex_c_ghost(void *v
){
228 struct a_lex_ghost
*lgp
, *gp
;
240 if((fp
= Ftmp(NULL
, "ghost", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
)
243 for(i
= 0, gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
244 fprintf(fp
, "wysh ghost %s %s\n",
245 gp
->lg_name
, n_shexp_quote_cp(gp
->lg_cmd
.s
, TRU1
));
248 page_or_print(fp
, i
);
254 /* Verify the ghost name is a valid one */
255 if(*argv
[0] == '\0' || *a_lex_isolate(argv
[0]) != '\0'){
256 n_err(_("`ghost': can't canonicalize %s\n"),
257 n_shexp_quote_cp(argv
[0], FAL0
));
262 /* Show command of single ghost? */
264 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
265 if(!strcmp(argv
[0], gp
->lg_name
)){
266 printf("wysh ghost %s %s\n",
267 gp
->lg_name
, n_shexp_quote_cp(gp
->lg_cmd
.s
, TRU1
));
270 n_err(_("`ghost': no such alias: %s\n"), argv
[0]);
275 /* Define command for ghost: verify command content */
276 for(cl
= 0, i
= 1; (cp
= n_UNCONST(argv
[i
])) != NULL
; ++i
)
278 cl
+= strlen(cp
) +1; /* SP or NUL */
280 n_err(_("`ghost': empty command arguments after %s\n"), argv
[0]);
285 /* If the ghost already exists, recreate */
286 for(lgp
= NULL
, gp
= a_lex_ghosts
; gp
!= NULL
; lgp
= gp
, gp
= gp
->lg_next
)
287 if(!strcmp(gp
->lg_name
, argv
[0])){
289 lgp
->lg_next
= gp
->lg_next
;
291 a_lex_ghosts
= gp
->lg_next
;
296 nl
= strlen(argv
[0]) +1;
297 gp
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_ghost
, lg_name
) + nl
+ cl
);
298 gp
->lg_next
= a_lex_ghosts
;
300 memcpy(gp
->lg_name
, argv
[0], nl
);
301 cp
= gp
->lg_cmd
.s
= gp
->lg_name
+ nl
;
304 while(*++argv
!= NULL
)
305 if((i
= strlen(*argv
)) > 0){
306 memcpy(cp
, *argv
, i
);
317 a_lex_c_unghost(void *v
){
318 struct a_lex_ghost
*lgp
, *gp
;
319 char const **argv
, *cp
;
326 while((cp
= *argv
++) != NULL
){
327 if(cp
[0] == '*' && cp
[1] == '\0'){
328 while((gp
= a_lex_ghosts
) != NULL
){
329 a_lex_ghosts
= gp
->lg_next
;
333 for(lgp
= NULL
, gp
= a_lex_ghosts
; gp
!= NULL
;
334 lgp
= gp
, gp
= gp
->lg_next
)
335 if(!strcmp(gp
->lg_name
, cp
)){
337 lgp
->lg_next
= gp
->lg_next
;
339 a_lex_ghosts
= gp
->lg_next
;
343 n_err(_("`unghost': no such alias: %s\n"),
344 n_shexp_quote_cp(cp
, FAL0
));
354 a_lex_cmdinfo(struct a_lex_cmd
const *lcp
){
355 struct n_string rvb
, *rv
;
359 rv
= n_string_creat_auto(&rvb
);
360 rv
= n_string_reserve(rv
, 80);
362 switch(lcp
->lc_argtype
& ARG_ARGMASK
){
363 case ARG_MSGLIST
: cp
= N_("message-list"); break;
364 case ARG_STRLIST
: cp
= N_("string data"); break;
365 case ARG_RAWLIST
: cp
= N_("old-style quoting"); break;
366 case ARG_NOLIST
: cp
= N_("no arguments"); break;
367 case ARG_NDMLIST
: cp
= N_("message-list (no default)"); break;
368 case ARG_WYSHLIST
: cp
= N_("sh(1)ell-style quoting"); break;
369 default: cp
= N_("`wysh' for sh(1)ell-style quoting"); break;
371 rv
= n_string_push_cp(rv
, V_(cp
));
373 if(lcp
->lc_argtype
& (ARG_A
| ARG_I
| ARG_M
| ARG_R
| ARG_S
| ARG_X
))
374 rv
= n_string_push_buf(rv
, " |", 2);
376 if(lcp
->lc_argtype
& ARG_A
)
377 rv
= n_string_push_cp(rv
, _(" needs box"));
378 if(lcp
->lc_argtype
& ARG_I
)
379 rv
= n_string_push_cp(rv
, _(" only interactive"));
380 if(lcp
->lc_argtype
& ARG_M
)
381 rv
= n_string_push_cp(rv
, _(" send mode"));
382 if(lcp
->lc_argtype
& ARG_R
)
383 rv
= n_string_push_cp(rv
, _(" no compose mode"));
384 if(lcp
->lc_argtype
& ARG_S
)
385 rv
= n_string_push_cp(rv
, _(" after startup"));
386 if(lcp
->lc_argtype
& ARG_X
)
387 rv
= n_string_push_cp(rv
, _(" subprocess"));
389 cp
= n_string_cp(rv
);
395 a_lex_c_list(void *v
){
397 struct a_lex_cmd
const **cpa
, *cp
, **cursor
;
401 i
= n_NELEM(a_lex_cmd_tab
) + n_NELEM(a_lex_special_cmd_tab
) +1;
402 cpa
= salloc(sizeof(cp
) * i
);
404 for(i
= 0; i
< n_NELEM(a_lex_cmd_tab
); ++i
)
405 cpa
[i
] = &a_lex_cmd_tab
[i
];
409 for(j
= 0; j
< n_NELEM(a_lex_special_cmd_tab
); ++i
, ++j
)
410 cpa
[i
] = &a_lex_special_cmd_tab
[j
];
418 qsort(cpa
, i
, sizeof(xcp
), &a_lex__pcmd_cmp
);
421 if((fp
= Ftmp(NULL
, "list", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
)
424 fprintf(fp
, _("Commands are:\n"));
426 for(i
= 0, cursor
= cpa
; (cp
= *cursor
++) != NULL
;){
427 if(cp
->lc_func
== &c_cmdnotsupp
)
429 if(options
& OPT_D_V
){
430 fprintf(fp
, "%s\n", cp
->lc_name
);
432 #ifdef HAVE_DOCSTRINGS
433 fprintf(fp
, " : %s\n", V_(cp
->lc_doc
));
436 fprintf(fp
, " : %s\n", a_lex_cmdinfo(cp
));
439 size_t j
= strlen(cp
->lc_name
) + 2;
446 fprintf(fp
, (*cursor
!= NULL
? "%s, " : "%s\n"), cp
->lc_name
);
451 page_or_print(fp
, l
);
459 a_lex__pcmd_cmp(void const *s1
, void const *s2
){
460 struct a_lex_cmd
const * const *cp1
, * const *cp2
;
466 rv
= strcmp((*cp1
)->lc_name
, (*cp2
)->lc_name
);
472 a_lex_c_help(void *v
){
477 /* Help for a single command? */
478 if((arg
= *(char**)v
) != NULL
){
479 struct a_lex_ghost
const *gp
;
480 struct a_lex_cmd
const *lcp
, *lcpmax
;
482 /* Ghosts take precedence */
483 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
484 if(!strcmp(arg
, gp
->lg_name
)){
485 printf("%s -> ", arg
);
490 lcpmax
= &(lcp
= a_lex_cmd_tab
)[n_NELEM(a_lex_cmd_tab
)];
492 for(; lcp
< lcpmax
; ++lcp
){
493 if(is_prefix(arg
, lcp
->lc_name
)){
495 if(strcmp(arg
, lcp
->lc_name
))
496 printf(" (%s)", lcp
->lc_name
);
500 #ifdef HAVE_DOCSTRINGS
501 printf(": %s", V_(lcp
->lc_doc
));
503 if(options
& OPT_D_V
)
504 printf("\n : %s", a_lex_cmdinfo(lcp
));
510 if(PTRCMP(lcpmax
, ==, &a_lex_cmd_tab
[n_NELEM(a_lex_cmd_tab
)])){
512 a_lex_special_cmd_tab
)[n_NELEM(a_lex_special_cmd_tab
)];
517 printf("%s\n", n_shexp_quote_cp(arg
, TRU1
));
520 n_err(_("Unknown command: `%s'\n"), arg
);
524 /* Very ugly, but take care for compiler supported string lengths :( */
525 fputs(progname
, stdout
);
527 " commands -- <msglist> denotes message specifications,\n"
528 "e.g., 1-5, :n or ., separated by spaces:\n"), stdout
);
531 "type <msglist> type (alias: `print') messages (honour `retain' etc.)\n"
532 "Type <msglist> like `type' but always show all headers\n"
533 "next goto and type next message\n"
534 "from <msglist> (search and) print header summary for the given list\n"
535 "headers header summary for messages surrounding \"dot\"\n"
536 "delete <msglist> delete messages (can be `undelete'd)\n"),
541 "save <msglist> folder append messages to folder and mark as saved\n"
542 "copy <msglist> folder like `save', but don't mark them (`move' moves)\n"
543 "write <msglist> file write message contents to file (prompts for parts)\n"
544 "Reply <msglist> reply to message senders only\n"
545 "reply <msglist> like `Reply', but address all recipients\n"
546 "Lreply <msglist> forced mailing-list `reply' (see `mlist')\n"),
551 "mail <recipients> compose a mail for the given recipients\n"
552 "file folder change to another mailbox\n"
553 "File folder like `file', but open readonly\n"
554 "quit quit and apply changes to the current mailbox\n"
555 "xit or exit like `quit', but discard changes\n"
556 "!shell command shell escape\n"
557 "list [<anything>] all available commands [in search order]\n"),
560 rv
= (ferror(stdout
) != 0);
568 a_lex_c_exit(void *v
){
572 if(pstate
& PS_STARTED
){
573 /* In recursed state, return error to just pop the input level */
574 if(!(pstate
& PS_SOURCING
)){
576 if((options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) ==
589 a_lex_c_quit(void *v
){
593 /* If we are PS_SOURCING, then return 1 so _evaluate() can handle it.
594 * Otherwise return -1 to abort command loop */
601 a_lex_c_version(void *v
){
604 char const *cp
, **arr
;
609 printf(_("%s version %s\nFeatures included (+) or not (-)\n"),
610 uagent
, ok_vlook(version
));
612 /* *features* starts with dummy byte to avoid + -> *folder* expansions */
613 i
= strlen(cp
= &ok_vlook(features
)[1]) +1;
617 arr
= salloc(sizeof(cp
) * VAL_FEATURES_CNT
);
618 for(longest
= 0, i
= 0; (cp
= n_strsep(&iop
, ',', TRU1
)) != NULL
; ++i
){
621 longest
= n_MAX(longest
, (int)i2
);
623 qsort(arr
, i
, sizeof(cp
), &a_lex__version_cmp
);
625 for(++longest
, i2
= 0; i
-- > 0;){
627 printf("%-*s ", longest
, cp
);
629 if(UICMP(z
, ++i2
+ longest
, >=, scrnwidth
) || i
== 0){
635 if((rv
= ferror(stdout
) != 0))
642 a_lex__version_cmp(void const *s1
, void const *s2
){
643 char const * const *cp1
, * const *cp2
;
649 rv
= strcmp(&(*cp1
)[1], &(*cp2
)[1]);
655 a_lex_update_pstate(void){
658 if(pstate
& PS_SIGWINCH_PEND
){
661 snprintf(buf
, sizeof buf
, "%d", scrnwidth
);
662 ok_vset(COLUMNS
, buf
);
663 snprintf(buf
, sizeof buf
, "%d", scrnheight
);
667 pstate
&= ~PS_PSTATE_PENDMASK
;
672 a_lex_evaluate(struct a_lex_eval_ctx
*evp
){
673 /* xxx old style(9), but also old code */
675 char _wordbuf
[2], *arglist
[MAXARGC
], *cp
, *word
;
676 struct a_lex_ghost
*gp
;
677 struct a_lex_cmd
const *cmd
;
686 line
= evp
->le_line
; /* XXX don't change original (buffer pointer) */
687 assert(line
.s
[line
.l
] == '\0');
688 evp
->le_add_history
= FAL0
;
689 evp
->le_new_content
= NULL
;
691 /* Command ghosts that refer to shell commands or macro expansion restart */
694 /* Strip the white space away from end and beginning of command */
698 for(cp
= &line
.s
[i
-1]; spacechar(*cp
); --cp
)
702 for(cp
= line
.s
; spacechar(*cp
); ++cp
)
704 line
.l
-= PTR2SIZE(cp
- line
.s
);
706 /* Ignore null commands (comments) */
710 /* Handle ! differently to get the correct lexical conventions */
714 /* Isolate the actual command; since it may not necessarily be
715 * separated from the arguments (as in `p1') we need to duplicate it to
716 * be able to create a NUL terminated version.
717 * We must be aware of several special one letter commands here */
718 else if((cp
= a_lex_isolate(cp
)) == arglist
[0] &&
719 (*cp
== '|' || *cp
== '~' || *cp
== '?'))
721 c
= (int)PTR2SIZE(cp
- arglist
[0]);
723 word
= UICMP(z
, c
, <, sizeof _wordbuf
) ? _wordbuf
: salloc(c
+1);
724 memcpy(word
, arglist
[0], c
);
727 /* Look up the command; if not found, bitch.
728 * Normally, a blank command would map to the first command in the
729 * table; while PS_SOURCING, however, we ignore blank lines to eliminate
730 * confusion; act just the same for ghosts */
732 if((pstate
& PS_ROBOT
) || gp
!= NULL
)
734 cmd
= a_lex_cmd_tab
+ 0;
738 /* XXX It may be the argument parse adjuster */
739 if(!wysh
&& c
== sizeof("wysh") -1 && !asccasecmp(word
, "wysh")){
745 /* If this is the first evaluation, check command ghosts */
747 /* TODO relink list head, so it's sorted on usage over time?
748 * TODO in fact, there should be one hashmap over all commands and ghosts
749 * TODO so that the lookup could be made much more efficient than it is
750 * TODO now (two adjacent list searches! */
751 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
752 if(!strcmp(word
, gp
->lg_name
)){
757 line
.s
= salloc(i
+ line
.l
+1);
758 memcpy(line
.s
, gp
->lg_cmd
.s
, i
);
759 memcpy(line
.s
+ i
, cp
, line
.l
);
760 line
.s
[i
+= line
.l
] = '\0';
763 line
.s
= gp
->lg_cmd
.s
;
764 line
.l
= gp
->lg_cmd
.l
;
770 if((cmd
= a_lex__firstfit(word
)) == NULL
|| cmd
->lc_func
== &c_cmdnotsupp
){
773 if(!(s
= condstack_isskip()) || (options
& OPT_D_V
))
774 n_err(_("Unknown command%s: `%s'\n"),
775 (s
? _(" (ignored due to `if' condition)") : n_empty
), word
);
785 /* See if we should execute the command -- if a conditional we always
786 * execute it, otherwise, check the state of cond */
788 if(!(cmd
->lc_argtype
& ARG_F
) && condstack_isskip())
791 /* Process the arguments to the command, depending on the type it expects */
792 if((cmd
->lc_argtype
& ARG_I
) &&
793 !(options
& (OPT_INTERACTIVE
| OPT_BATCH_FLAG
))){
794 n_err(_("May not execute `%s' unless interactive or in batch mode\n"),
798 if(!(cmd
->lc_argtype
& ARG_M
) && (options
& OPT_SENDMODE
)){
799 n_err(_("May not execute `%s' while sending\n"), cmd
->lc_name
);
802 if(cmd
->lc_argtype
& ARG_R
){
803 if(pstate
& PS_COMPOSE_MODE
){
804 /* TODO PS_COMPOSE_MODE: should allow `reply': ~:reply! */
805 n_err(_("Cannot invoke `%s' when in compose mode\n"), cmd
->lc_name
);
808 /* TODO Nothing should prevent ARG_R in conjunction with
809 * TODO PS_ROBOT|_SOURCING; see a.._may_yield_control()! */
810 if(pstate
& (PS_ROBOT
| PS_SOURCING
)){
811 n_err(_("Cannot invoke `%s' from a macro or during file inclusion\n"),
816 if((cmd
->lc_argtype
& ARG_S
) && !(pstate
& PS_STARTED
)){
817 n_err(_("May not execute `%s' during startup\n"), cmd
->lc_name
);
820 if(!(cmd
->lc_argtype
& ARG_X
) && (pstate
& PS_COMPOSE_FORKHOOK
)){
821 n_err(_("Cannot invoke `%s' from a hook running in a child process\n"),
826 if((cmd
->lc_argtype
& ARG_A
) && mb
.mb_type
== MB_VOID
){
827 n_err(_("Cannot execute `%s' without active mailbox\n"), cmd
->lc_name
);
830 if((cmd
->lc_argtype
& ARG_W
) && !(mb
.mb_perm
& MB_DELE
)){
831 n_err(_("May not execute `%s' -- message file is read only\n"),
836 if(cmd
->lc_argtype
& ARG_O
)
837 OBSOLETE2(_("this command will be removed"), cmd
->lc_name
);
838 if(cmd
->lc_argtype
& ARG_V
)
839 temporary_arg_v_store
= NULL
;
841 if(wysh
&& (cmd
->lc_argtype
& ARG_ARGMASK
) != ARG_WYRALIST
)
842 n_err(_("`wysh' prefix doesn't affect `%s'\n"), cmd
->lc_name
);
843 /* TODO v15: strip PS_ARGLIST_MASK off, just in case the actual command
844 * TODO doesn't use any of those list commands which strip this mask,
845 * TODO and for now we misuse bits for checking relation to history;
846 * TODO argument state should be property of a per-command carrier instead */
847 pstate
&= ~PS_ARGLIST_MASK
;
848 switch(cmd
->lc_argtype
& ARG_ARGMASK
){
850 /* Message list defaulting to nearest forward legal message */
853 if((c
= getmsglist(cp
, n_msgvec
, cmd
->lc_msgflag
)) < 0)
856 if((n_msgvec
[0] = first(cmd
->lc_msgflag
, cmd
->lc_msgmask
)) != 0)
859 if(n_msgvec
[0] == 0){
860 if(!(pstate
& PS_HOOK_MASK
))
861 printf(_("No applicable messages\n"));
864 e
= (*cmd
->lc_func
)(n_msgvec
);
868 /* Message list with no defaults, but no error if none exist */
869 if(n_msgvec
== NULL
){
871 n_err(_("Invalid use of message list\n"));
874 if((c
= getmsglist(cp
, n_msgvec
, cmd
->lc_msgflag
)) < 0)
876 e
= (*cmd
->lc_func
)(n_msgvec
);
880 /* Just the straight string, with leading blanks removed */
881 while(whitechar(*cp
))
883 e
= (*cmd
->lc_func
)(cp
);
898 if((c
= getrawlist((c
!= 0), arglist
, n_NELEM(arglist
), cp
, line
.l
)) < 0){
899 n_err(_("Invalid argument list\n"));
902 if(c
< cmd
->lc_minargs
){
903 n_err(_("`%s' requires at least %d arg(s)\n"),
904 cmd
->lc_name
, cmd
->lc_minargs
);
908 if(c
> cmd
->lc_maxargs
){
909 n_err(_("`%s' takes no more than %d arg(s)\n"),
910 cmd
->lc_name
, cmd
->lc_maxargs
);
914 e
= (*cmd
->lc_func
)(arglist
);
918 /* Just the constant zero, for exiting, eg. */
919 e
= (*cmd
->lc_func
)(0);
923 DBG( n_panic(_("Implementation error: unknown argument type: %d"),
924 cmd
->lc_argtype
& ARG_ARGMASK
); )
928 if(e
== 0 && (cmd
->lc_argtype
& ARG_V
) &&
929 (cp
= temporary_arg_v_store
) != NULL
){
930 temporary_arg_v_store
= NULL
;
931 evp
->le_new_content
= cp
;
934 if(!(cmd
->lc_argtype
& ARG_H
))
935 evp
->le_add_history
= (((cmd
->lc_argtype
& ARG_G
) ||
936 (pstate
& PS_MSGLIST_GABBY
)) ? TRUM1
: TRU1
);
940 bool_t reset
= !(pstate
& PS_ROOT
);
943 ok_vset(_exit_status
, (e
== 0 ? "0" : "1")); /* TODO num=1 +real value! */
948 /* Exit the current source file on error TODO what a mess! */
950 pstate
&= ~PS_EVAL_ERROR
;
952 pstate
|= PS_EVAL_ERROR
;
953 if(e
< 0 || (pstate
& PS_ROBOT
)){ /* FIXME */
962 if((cmd
->lc_argtype
& ARG_P
) && ok_blook(autoprint
))
964 line
.s
= savestr("type");
965 line
.l
= sizeof("type") -1;
966 gp
= (struct a_lex_ghost
*)-1; /* Avoid `ghost' interpretation */
970 if(!(pstate
& (PS_SOURCING
| PS_HOOK_MASK
)) && !(cmd
->lc_argtype
& ARG_T
))
971 pstate
|= PS_SAW_COMMAND
;
973 pstate
&= ~PS_EVAL_ERROR
;
978 fprintf(stderr, "a_lex_evaluate returns %d for <%s>\n",e,line.s);
984 static struct a_lex_cmd
const *
985 a_lex__firstfit(char const *comm
){ /* TODO *hashtable*! linear list search!!! */
986 struct a_lex_cmd
const *cp
;
989 for(cp
= a_lex_cmd_tab
;
990 PTRCMP(cp
, <, &a_lex_cmd_tab
[n_NELEM(a_lex_cmd_tab
)]); ++cp
)
991 if(*comm
== *cp
->lc_name
&& is_prefix(comm
, cp
->lc_name
))
1000 a_lex_hangup(int s
){
1001 NYD_X
; /* Signal handler */
1003 /* nothing to do? */
1008 a_lex_onintr(int s
){ /* TODO block signals while acting */
1009 NYD_X
; /* Signal handler */
1012 safe_signal(SIGINT
, a_lex_onintr
);
1014 termios_state_reset();
1015 close_all_files(); /* FIXME .. of current level ONLU! */
1021 a_lex_unstack(TRUM1
);
1024 n_err_sighdl(_("Interrupt\n"));
1025 safe_signal(SIGPIPE
, a_lex_oldpipe
);
1026 siglongjmp(a_lex_srbuf
, 0); /* FIXME get rid */
1030 a_lex_unstack(bool_t eval_error
){
1031 struct a_lex_input_stack
*lip
;
1034 if((lip
= a_lex_input
) == NULL
){
1037 /* If called from a_lex_onintr(), be silent FIXME */
1038 pstate
&= ~(PS_SOURCING
| PS_ROBOT
);
1039 if(eval_error
== TRUM1
|| !(pstate
& PS_STARTED
))
1044 if(lip
->li_flags
& a_LEX_SLICE
){ /* TODO Temporary hack */
1045 stdin
= lip
->li_slice_stdin
;
1046 stdout
= lip
->li_slice_stdout
;
1047 options
= lip
->li_slice_options
;
1048 goto jthe_slice_hack
;
1051 if(lip
->li_flags
& a_LEX_MACRO
){
1052 if(lip
->li_flags
& a_LEX_MACRO_FREE_DATA
){
1055 while(*(lp
= &lip
->li_lines
[lip
->li_loff
]) != NULL
){
1059 /* Part of lip's memory chunk, then */
1060 if(!(lip
->li_flags
& a_LEX_MACRO_CMD
))
1061 free(lip
->li_lines
);
1064 if(lip
->li_flags
& a_LEX_PIPE
)
1065 /* XXX command manager should -TERM then -KILL instead of hoping
1066 * XXX for exit of provider due to EPIPE / SIGPIPE */
1067 Pclose(lip
->li_file
, TRU1
);
1069 Fclose(lip
->li_file
);
1072 if(!condstack_take(lip
->li_cond
)){
1073 n_err(_("Unmatched `if' at end of %s %s\n"),
1074 ((lip
->li_flags
& a_LEX_MACRO
1075 ? (lip
->li_flags
& a_LEX_MACRO_CMD
? _("command") : _("macro"))
1076 : _("`source'd file"))),
1081 n_memory_autorec_pop(&lip
->li_autorecmem
[0]);
1084 if(lip
->li_on_finalize
!= NULL
)
1085 (*lip
->li_on_finalize
)(lip
->li_finalize_arg
);
1087 if((a_lex_input
= lip
->li_outer
) == NULL
){
1088 pstate
&= ~(PS_SOURCING
| PS_ROBOT
);
1090 if((a_lex_input
->li_flags
& (a_LEX_MACRO
| a_LEX_SUPER_MACRO
)) ==
1091 (a_LEX_MACRO
| a_LEX_SUPER_MACRO
))
1092 pstate
&= ~PS_SOURCING
;
1093 assert(pstate
& PS_ROBOT
);
1099 if(lip
!= NULL
&& (lip
->li_flags
& a_LEX_FREE
))
1101 if(n_UNLIKELY(a_lex_input
!= NULL
&& eval_error
== TRUM1
))
1102 a_lex_unstack(TRUM1
);
1108 if(options
& OPT_D_V
)
1109 n_alert(_("Stopped %s %s due to errors%s"),
1110 (pstate
& PS_STARTED
1111 ? (lip
->li_flags
& a_LEX_SLICE
? _("sliced in program")
1112 : (lip
->li_flags
& a_LEX_MACRO
1113 ? (lip
->li_flags
& a_LEX_MACRO_CMD
1114 ? _("evaluating command") : _("evaluating macro"))
1115 : (lip
->li_flags
& a_LEX_PIPE
1116 ? _("executing `source'd pipe")
1117 : _("loading `source'd file")))
1119 : (lip
->li_flags
& a_LEX_MACRO
1120 ? (lip
->li_flags
& a_LEX_MACRO_X_OPTION
1121 ? _("evaluating command line") : _("evaluating macro"))
1122 : _("loading initialization resource"))),
1124 (options
& OPT_DEBUG
? n_empty
: _(" (enable *debug* for trace)")));
1127 if(!(options
& OPT_INTERACTIVE
) && !(pstate
& PS_STARTED
)){
1128 if(options
& OPT_D_V
)
1129 n_alert(_("Non-interactive, bailing out due to errors "
1130 "in startup load phase"));
1137 a_lex_source_file(char const *file
, bool_t silent_error
){
1138 struct a_lex_input_stack
*lip
;
1147 /* Being a command argument file is space-trimmed *//* TODO v15 with
1148 * TODO WYRALIST this is no longer necessary true, and for that we
1149 * TODO don't set _PARSE_TRIMSPACE because we cannot! -> cmd_tab.h!! */
1151 ((ispipe
= (!silent_error
&& (nlen
= strlen(file
)) > 0 &&
1152 file
[--nlen
] == '|')))
1156 for(nlen
= strlen(file
); nlen
> 0;){
1162 nbuf
= savestrbuf(file
, nlen
);
1171 if((fip
= Popen(nbuf
/* #if 0 above = savestrbuf(file, nlen)*/, "r",
1172 ok_vlook(SHELL
), NULL
, COMMAND_FD_NULL
)) == NULL
){
1173 if(!silent_error
|| (options
& OPT_D_V
))
1177 }else if((nbuf
= fexpand(file
, FEXP_LOCAL
)) == NULL
)
1179 else if((fip
= Fopen(nbuf
, "r")) == NULL
){
1180 if(!silent_error
|| (options
& OPT_D_V
))
1185 lip
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
) +
1186 (nlen
= strlen(nbuf
) +1));
1187 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1188 lip
->li_outer
= a_lex_input
;
1190 lip
->li_cond
= condstack_release();
1191 n_memory_autorec_push(&lip
->li_autorecmem
[0]);
1192 lip
->li_flags
= (ispipe
? a_LEX_FREE
| a_LEX_PIPE
: a_LEX_FREE
) |
1193 (a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
1194 ? a_LEX_SUPER_MACRO
: 0);
1195 memcpy(lip
->li_name
, nbuf
, nlen
);
1197 pstate
|= PS_SOURCING
| PS_ROBOT
;
1199 a_commands_recursive(n_LEXINPUT_NONE
| n_LEXINPUT_NL_ESC
);
1200 /* FIXME return TRUM1 if file can't be opened, FAL0 on eval error */
1203 return silent_error
? TRU1
: (fip
!= NULL
);
1207 a_lex_load(struct a_lex_input_stack
*lip
){
1211 assert(!(pstate
& PS_STARTED
));
1212 assert(a_lex_input
== NULL
);
1215 * Any errors in the start-up file shall either cause mailx to terminate
1216 * with a diagnostic message and a non-zero status or to continue after
1217 * writing a diagnostic message, ignoring the remainder of the lines in
1218 * the start-up file. */
1219 lip
->li_cond
= condstack_release();
1220 n_memory_autorec_push(&lip
->li_autorecmem
[0]);
1222 /* FIXME won't work for now (PS_ROBOT needs PS_SOURCING anyway)
1223 pstate |= PS_ROBOT |
1224 (lip->li_flags & a_LEX_MACRO_X_OPTION ? 0 : PS_SOURCING);
1226 pstate
|= PS_ROBOT
| PS_SOURCING
;
1227 if(options
& OPT_D_V
)
1228 n_err(_("Loading %s\n"), n_shexp_quote_cp(lip
->li_name
, FAL0
));
1230 if(!(rv
= n_commands())){
1231 if(!(options
& OPT_INTERACTIVE
)){
1232 if(options
& OPT_D_V
)
1233 n_alert(_("Non-interactive program mode, forced exit"));
1237 /* PS_EXIT handled by callers */
1243 a_lex__cmdrecint(int sig
){ /* TODO one day, we don't need it no more */
1244 NYD_X
; /* Signal handler */
1246 siglongjmp(a_lex_input
->li_cmdrec_jmp
, 1);
1250 a_commands_recursive(enum n_lexinput_flags lif
){
1251 volatile int hadint
; /* TODO get rid of shitty signal stuff (see signal.c) */
1252 sighandler_type soldhdl
;
1253 sigset_t sintset
, soldset
;
1254 struct a_lex_eval_ctx ev
;
1258 memset(&ev
, 0, sizeof ev
);
1260 sigfillset(&sintset
);
1261 sigprocmask(SIG_BLOCK
, &sintset
, &soldset
);
1263 if((soldhdl
= safe_signal(SIGINT
, SIG_IGN
)) != SIG_IGN
){
1264 safe_signal(SIGINT
, &a_lex__cmdrecint
);
1265 if(sigsetjmp(a_lex_input
->li_cmdrec_jmp
, 1)){
1270 sigprocmask(SIG_SETMASK
, &soldset
, NULL
);
1272 n_COLOUR( n_colour_env_push(); )
1277 /* Read a line of commands and handle end of file specially */
1278 ev
.le_line
.l
= ev
.le_line_size
;
1279 n
= n_lex_input(lif
, NULL
, &ev
.le_line
.s
, &ev
.le_line
.l
,
1281 ev
.le_line_size
= (ui32_t
)ev
.le_line
.l
;
1282 ev
.le_line
.l
= (ui32_t
)n
;
1287 if(a_lex_evaluate(&ev
)){
1293 if((options
& OPT_BATCH_FLAG
) && ok_blook(batch_exit_on_error
)){
1294 if(exit_status
!= EXIT_OK
)
1300 n_COLOUR( n_colour_env_pop(FAL0
); )
1302 if(ev
.le_line
.s
!= NULL
)
1305 if(soldhdl
!= SIG_IGN
)
1306 safe_signal(SIGINT
, soldhdl
);
1309 sigprocmask(SIG_SETMASK
, &soldset
, NULL
);
1316 c_cmdnotsupp(void *vp
){
1319 n_err(_("The requested feature is not compiled in\n"));
1325 n_commands(void){ /* FIXME */
1326 struct a_lex_eval_ctx ev
;
1333 if (!(pstate
& PS_SOURCING
)) {
1334 if (safe_signal(SIGINT
, SIG_IGN
) != SIG_IGN
)
1335 safe_signal(SIGINT
, &a_lex_onintr
);
1336 if (safe_signal(SIGHUP
, SIG_IGN
) != SIG_IGN
)
1337 safe_signal(SIGHUP
, &a_lex_hangup
);
1339 a_lex_oldpipe
= safe_signal(SIGPIPE
, SIG_IGN
);
1340 safe_signal(SIGPIPE
, a_lex_oldpipe
);
1342 memset(&ev
, 0, sizeof ev
);
1344 (void)sigsetjmp(a_lex_srbuf
, 1); /* FIXME get rid */
1346 char *temporary_orig_line
; /* XXX eval_ctx.le_line not yet constant */
1348 n_COLOUR( n_colour_env_pop(TRU1
); )
1350 /* TODO Unless we have our signal manager (or however we do it) child
1351 * TODO processes may have time slots where their execution isn't
1352 * TODO protected by signal handlers (in between start and setup
1353 * TODO completed). close_all_files() is only called from onintr()
1354 * TODO so those may linger possibly forever */
1355 if(!(pstate
& PS_SOURCING
))
1362 if (!(pstate
& PS_SOURCING
)) {
1365 /* TODO Note: this buffer may contain a password. We should redefine
1366 * TODO the code flow which has to do that */
1367 if ((cp
= termios_state
.ts_linebuf
) != NULL
) {
1368 termios_state
.ts_linebuf
= NULL
;
1369 termios_state
.ts_linesize
= 0;
1370 free(cp
); /* TODO pool give-back */
1372 /* TODO Due to expand-on-tab of NCL the buffer may grow */
1373 if (ev
.le_line
.l
> LINESIZE
* 3) {
1374 free(ev
.le_line
.s
); /* TODO pool! but what? */
1375 ev
.le_line
.s
= NULL
;
1376 ev
.le_line
.l
= ev
.le_line_size
= 0;
1380 if (!(pstate
& PS_SOURCING
) && (options
& OPT_INTERACTIVE
)) {
1383 cp
= ok_vlook(newmail
);
1384 if ((options
& OPT_TTYIN
) && cp
!= NULL
) {
1387 /* FIXME TEST WITH NOPOLL ETC. !!! */
1388 n
= (cp
!= NULL
&& strcmp(cp
, "nopoll"));
1389 if ((mb
.mb_type
== MB_FILE
&& !stat(mailname
, &st
) &&
1390 st
.st_size
> mailsize
) ||
1391 (mb
.mb_type
== MB_MAILDIR
&& n
!= 0)) {
1392 size_t odot
= PTR2SIZE(dot
- message
);
1393 ui32_t odid
= (pstate
& PS_DID_PRINT_DOT
);
1395 if (setfile(mailname
,
1397 ((mb
.mb_perm
& MB_DELE
) ? 0 : FEDIT_RDONLY
)) < 0) {
1398 exit_status
|= EXIT_ERR
;
1402 dot
= message
+ odot
;
1407 exit_status
= EXIT_OK
;
1410 /* Read a line of commands and handle end of file specially */
1412 ev
.le_line
.l
= ev
.le_line_size
;
1413 n
= n_lex_input(n_LEXINPUT_CTX_DEFAULT
| n_LEXINPUT_NL_ESC
, NULL
,
1414 &ev
.le_line
.s
, &ev
.le_line
.l
, ev
.le_new_content
);
1415 ev
.le_line_size
= (ui32_t
)ev
.le_line
.l
;
1416 ev
.le_line
.l
= (ui32_t
)n
;
1419 /* FIXME did unstack() when PS_SOURCING, only break with PS_LOADING*/
1420 if (!(pstate
& PS_ROBOT
) &&
1421 (options
& OPT_INTERACTIVE
) && ok_blook(ignoreeof
)) {
1422 printf(_("*ignoreeof* set, use `quit' to quit.\n"));
1423 n_msleep(500, FAL0
);
1429 temporary_orig_line
= ((pstate
& PS_SOURCING
) ||
1430 !(options
& OPT_INTERACTIVE
)) ? NULL
1431 : savestrbuf(ev
.le_line
.s
, ev
.le_line
.l
);
1432 pstate
&= ~PS_HOOK_MASK
;
1433 if (a_lex_evaluate(&ev
)) {
1434 if (!(pstate
& PS_STARTED
)) /* TODO mess; join PS_EVAL_ERROR.. */
1439 if ((options
& OPT_BATCH_FLAG
) && ok_blook(batch_exit_on_error
)) {
1440 if (exit_status
!= EXIT_OK
)
1442 if ((pstate
& (PS_SOURCING
| PS_EVAL_ERROR
)) == PS_EVAL_ERROR
) {
1443 exit_status
= EXIT_ERR
;
1447 if (!(pstate
& PS_SOURCING
) && (options
& OPT_INTERACTIVE
)) {
1448 if (ev
.le_new_content
!= NULL
)
1450 /* *Can* happen since _evaluate() n_unstack()s on error! XXX no more */
1451 if (temporary_orig_line
!= NULL
)
1452 n_tty_addhist(temporary_orig_line
, (ev
.le_add_history
!= TRU1
));
1455 if(pstate
& PS_EXIT
)
1461 if (ev
.le_line
.s
!= NULL
)
1468 (n_lex_input
)(enum n_lexinput_flags lif
, char const *prompt
, char **linebuf
,
1469 size_t *linesize
, char const *string n_MEMORY_DEBUG_ARGS
){
1470 /* TODO readline: linebuf pool!; n_lex_input should return si64_t */
1471 struct n_string xprompt
;
1473 bool_t doprompt
, dotty
;
1478 /* Special case macro mode: never need to prompt, lines have always been
1479 * unfolded already */
1480 if(!(lif
& n_LEXINPUT_FORCE_STDIN
) &&
1481 a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_MACRO
)){
1482 if(*linebuf
!= NULL
)
1485 if((*linebuf
= a_lex_input
->li_lines
[a_lex_input
->li_loff
]) == NULL
){
1491 ++a_lex_input
->li_loff
;
1492 *linesize
= strlen(*linebuf
);
1493 if(!(a_lex_input
->li_flags
& a_LEX_MACRO_FREE_DATA
))
1494 *linebuf
= sbufdup(*linebuf
, *linesize
);
1496 iftype
= (a_lex_input
->li_flags
& a_LEX_MACRO_X_OPTION
)
1498 : (a_lex_input
->li_flags
& a_LEX_MACRO_CMD
) ? "CMD" : "MACRO";
1500 pstate
|= PS_READLINE_NL
;
1503 pstate
&= ~PS_READLINE_NL
;
1505 iftype
= (!(pstate
& PS_STARTED
) ? "LOAD"
1506 : (pstate
& PS_SOURCING
) ? "SOURCE" : "READ");
1507 doprompt
= ((pstate
& (PS_STARTED
| PS_ROBOT
)) == PS_STARTED
&&
1508 (options
& OPT_INTERACTIVE
));
1509 dotty
= (doprompt
&& !ok_blook(line_editor_disable
));
1511 lif
|= n_LEXINPUT_PROMPT_NONE
;
1514 n_string_creat_auto(&xprompt
);
1516 lif
|= n_LEXINPUT_PROMPT_EVAL
;
1519 /* Ensure stdout is flushed first anyway */
1520 if(!dotty
&& (lif
& n_LEXINPUT_PROMPT_NONE
))
1523 ifile
= (a_lex_input
!= NULL
) ? a_lex_input
->li_file
: stdin
;
1525 assert((pstate
& PS_COMPOSE_FORKHOOK
) &&
1526 a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_MACRO
));
1530 for(nold
= n
= 0;;){
1532 assert(ifile
== stdin
);
1533 if(string
!= NULL
&& (n
= (int)strlen(string
)) > 0){
1537 *linesize
= (size_t)n
+ LINESIZE
+1;
1538 *linebuf
= (n_realloc
)(*linebuf
, *linesize n_MEMORY_DEBUG_ARGSCALL
);
1539 memcpy(*linebuf
, string
, (size_t)n
+1);
1542 /* TODO if nold>0, don't redisplay the entire line!
1543 * TODO needs complete redesign ... */
1544 n
= (n_tty_readline
)(lif
, prompt
, linebuf
, linesize
, n
1545 n_MEMORY_DEBUG_ARGSCALL
);
1547 if(!(lif
& n_LEXINPUT_PROMPT_NONE
)){
1548 n_tty_create_prompt(&xprompt
, prompt
, lif
);
1549 if(xprompt
.s_len
> 0){
1550 fwrite(xprompt
.s_dat
, 1, xprompt
.s_len
, stdout
);
1555 n
= (readline_restart
)(ifile
, linebuf
, linesize
, n
1556 n_MEMORY_DEBUG_ARGSCALL
);
1558 if(n
> 0 && nold
> 0){
1560 char const *cp
= *linebuf
+ nold
;
1562 while(blankspacechar(*cp
) && nold
+ i
< n
)
1565 memmove(*linebuf
+ nold
, cp
, n
- nold
- i
);
1567 (*linebuf
)[n
] = '\0';
1576 * An unquoted <backslash> at the end of a command line shall
1577 * be discarded and the next line shall continue the command */
1578 if(!(lif
& n_LEXINPUT_NL_ESC
) || (*linebuf
)[n
- 1] != '\\'){
1580 pstate
|= PS_READLINE_NL
;
1583 /* Definitely outside of quotes, thus the quoting rules are so that an
1584 * uneven number of successive backslashs at EOL is a continuation */
1588 for(j
= 1, i
= (size_t)n
- 1; i
-- > 0; ++j
)
1589 if((*linebuf
)[i
] != '\\')
1594 (*linebuf
)[nold
= --n
] = '\0';
1595 lif
|= n_LEXINPUT_NL_FOLLOW
;
1600 (*linebuf
)[*linesize
= n
] = '\0';
1604 if(lif
& n_LEXINPUT_DROP_TRAIL_SPC
){
1608 for(cp
= &(*linebuf
)[i
= (size_t)n
];; --i
){
1610 if(!blankspacechar(c
))
1613 (*linebuf
)[n
= (int)i
] = '\0';
1616 if(lif
& n_LEXINPUT_DROP_LEAD_SPC
){
1620 for(cp
= &(*linebuf
)[0], j
= (size_t)n
, i
= 0; i
< j
; ++i
){
1622 if(!blankspacechar(c
))
1626 memcpy(&(*linebuf
)[0], &(*linebuf
)[i
], j
-= i
);
1627 (*linebuf
)[n
= (int)j
] = '\0';
1630 #endif /* 0 (notyet - must take care for backslash escaped space) */
1632 if(options
& OPT_D_VV
)
1633 n_err(_("%s %d bytes <%s>\n"), iftype
, n
, *linebuf
);
1635 if (pstate
& PS_PSTATE_PENDMASK
)
1636 a_lex_update_pstate();
1638 /* TODO We need to special case a_LEX_SLICE, since that is not managed by us
1639 * TODO but only established from the outside and we need to drop this
1640 * TODO overlay context somehow */
1641 if(n
< 0 && a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_SLICE
))
1642 a_lex_unstack(FAL0
);
1648 n_lex_input_cp(enum n_lexinput_flags lif
, char const *prompt
,
1649 char const *string
){
1650 /* FIXME n_lex_input_cp_addhist(): leaks on sigjmp without linepool */
1660 n
= n_lex_input(lif
, prompt
, &linebuf
, &linesize
, string
);
1661 if(n
> 0 && *(rv
= savestrbuf(linebuf
, (size_t)n
)) != '\0' &&
1662 (lif
& n_LEXINPUT_HIST_ADD
) && (options
& OPT_INTERACTIVE
))
1663 n_tty_addhist(rv
, ((lif
& n_LEXINPUT_HIST_GABBY
) != 0));
1672 c_read(void *v
){ /* TODO IFS? how? -r */
1673 char const **argv
, *cp
, *cp2
;
1678 for(argv
= v
; (cp
= *argv
++) != NULL
;)
1679 if(!n_shexp_is_valid_varname(cp
)){
1680 n_err(_("`read': not a valid variable name: %s\n"),
1681 n_shexp_quote_cp(cp
, FAL0
));
1687 cp
= n_lex_input_cp(((pstate
& PS_COMPOSE_MODE
1688 ? n_LEXINPUT_CTX_COMPOSE
: n_LEXINPUT_CTX_DEFAULT
) |
1689 n_LEXINPUT_FORCE_STDIN
| n_LEXINPUT_NL_ESC
|
1690 n_LEXINPUT_PROMPT_NONE
/* XXX POSIX: PS2: yes! */),
1695 for(argv
= v
; *argv
!= NULL
; ++argv
){
1698 while(blankchar(*cp
))
1703 /* The last variable gets the remaining line less trailing IFS */
1704 if(argv
[1] == NULL
){
1705 for(cp2
= cp
; *cp2
!= '\0'; ++cp2
)
1707 for(; cp2
> cp
; --cp2
){
1713 for(cp2
= cp
; (c
= *++cp2
) != '\0';)
1717 vok_vset(*argv
, savestrbuf(cp
, PTR2SIZE(cp2
- cp
)));
1721 /* Set the remains to the empty string */
1722 for(; *argv
!= NULL
; ++argv
)
1723 vok_vset(*argv
, "");
1732 n_load(char const *name
){
1733 struct a_lex_input_stack
*lip
;
1738 if(name
== NULL
|| *name
== '\0' || (fip
= Fopen(name
, "r")) == NULL
)
1741 i
= strlen(name
) +1;
1742 lip
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
) + i
);
1743 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1745 lip
->li_flags
= a_LEX_FREE
;
1746 memcpy(lip
->li_name
, name
, i
);
1755 n_load_Xargs(char const **lines
, size_t cnt
){
1756 static char const name
[] = "-X";
1758 ui8_t buf
[sizeof(struct a_lex_input_stack
) + sizeof name
];
1759 char const *srcp
, *xsrcp
;
1761 size_t imax
, i
, len
;
1762 struct a_lex_input_stack
*lip
;
1766 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1767 lip
->li_flags
= a_LEX_MACRO
| a_LEX_MACRO_FREE_DATA
|
1768 a_LEX_MACRO_X_OPTION
| a_LEX_SUPER_MACRO
;
1769 memcpy(lip
->li_name
, name
, sizeof name
);
1771 /* The problem being that we want to support reverse solidus newline
1772 * escaping also within multiline -X, i.e., POSIX says:
1773 * An unquoted <backslash> at the end of a command line shall
1774 * be discarded and the next line shall continue the command
1775 * Therefore instead of "lip->li_lines = n_UNCONST(lines)", duplicate the
1776 * entire lines array and set _MACRO_FREE_DATA */
1778 lip
->li_lines
= smalloc(sizeof(*lip
->li_lines
) * imax
);
1780 /* For each of the input lines.. */
1781 for(i
= len
= 0, cp
= NULL
; cnt
> 0;){
1785 if((j
= strlen(srcp
= *lines
)) == 0){
1790 /* Separate one line from a possible multiline input string */
1791 if((xsrcp
= memchr(srcp
, '\n', j
)) != NULL
){
1793 j
= PTR2SIZE(xsrcp
- srcp
);
1797 /* The (separated) string may itself indicate soft newline escaping */
1798 if((keep
= (srcp
[j
- 1] == '\\'))){
1801 /* Need an uneven number of reverse solidus */
1802 for(xk
= 1, xj
= j
- 1; xj
-- > 0; ++xk
)
1803 if(srcp
[xj
] != '\\')
1811 /* Strip any leading WS from follow lines, then */
1813 while(j
> 0 && blankspacechar(*srcp
))
1817 if(i
+ 2 >= imax
){ /* TODO need a vector (main.c, here, ++) */
1819 lip
->li_lines
= n_realloc(lip
->li_lines
, sizeof(*lip
->li_lines
) *
1822 lip
->li_lines
[i
] = cp
= n_realloc(cp
, len
+ j
+1);
1823 memcpy(&cp
[len
], srcp
, j
);
1824 cp
[len
+= j
] = '\0';
1833 assert(i
+ 1 < imax
);
1834 lip
->li_lines
[i
++] = cp
;
1836 lip
->li_lines
[i
] = NULL
;
1839 if(pstate
& PS_EXIT
)
1849 rv
= (a_lex_source_file(*(char**)v
, FAL0
) == TRU1
) ? 0 : 1;
1855 c_source_if(void *v
){ /* XXX obsolete?, support file tests in `if' etc.! */
1859 rv
= (a_lex_source_file(*(char**)v
, TRU1
) != FAL0
) ? 0 : 1;
1865 n_source_macro(enum n_lexinput_flags lif
, char const *name
, char **lines
,
1866 void (*on_finalize
)(void*), void *finalize_arg
){
1867 struct a_lex_input_stack
*lip
;
1872 lip
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
) +
1873 (i
= strlen(name
) +1));
1874 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1875 lip
->li_outer
= a_lex_input
;
1876 lip
->li_file
= NULL
;
1877 lip
->li_cond
= condstack_release();
1878 n_memory_autorec_push(&lip
->li_autorecmem
[0]);
1879 lip
->li_flags
= a_LEX_FREE
| a_LEX_MACRO
| a_LEX_MACRO_FREE_DATA
|
1880 (a_lex_input
== NULL
|| (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
1881 ? a_LEX_SUPER_MACRO
: 0);
1882 lip
->li_lines
= lines
;
1883 lip
->li_on_finalize
= on_finalize
;
1884 lip
->li_finalize_arg
= finalize_arg
;
1885 memcpy(lip
->li_name
, name
, i
);
1889 rv
= a_commands_recursive(lif
);
1895 n_source_command(enum n_lexinput_flags lif
, char const *cmd
){
1896 struct a_lex_input_stack
*lip
;
1904 lip
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
) +
1905 ial
+ 2*sizeof(char*));
1906 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1907 lip
->li_outer
= a_lex_input
;
1908 lip
->li_cond
= condstack_release();
1909 n_memory_autorec_push(&lip
->li_autorecmem
[0]);
1910 lip
->li_flags
= a_LEX_FREE
| a_LEX_MACRO
| a_LEX_MACRO_CMD
|
1911 (a_lex_input
== NULL
|| (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
1912 ? a_LEX_SUPER_MACRO
: 0);
1913 lip
->li_lines
= (void*)&lip
->li_name
[ial
];
1914 memcpy(lip
->li_lines
[0] = &lip
->li_name
[0], cmd
, i
);
1915 lip
->li_lines
[1] = NULL
;
1919 rv
= a_commands_recursive(lif
);
1925 n_source_slice_hack(char const *cmd
, FILE *new_stdin
, FILE *new_stdout
,
1926 ui32_t new_options
, void (*on_finalize
)(void*), void *finalize_arg
){
1927 struct a_lex_input_stack
*lip
;
1931 lip
= smalloc(n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
) +
1932 (i
= strlen(cmd
) +1));
1933 memset(lip
, 0, n_VSTRUCT_SIZEOF(struct a_lex_input_stack
, li_name
));
1934 lip
->li_outer
= a_lex_input
;
1935 lip
->li_file
= new_stdin
;
1936 lip
->li_flags
= a_LEX_FREE
| a_LEX_SLICE
;
1937 lip
->li_on_finalize
= on_finalize
;
1938 lip
->li_finalize_arg
= finalize_arg
;
1939 lip
->li_slice_stdin
= stdin
;
1940 lip
->li_slice_stdout
= stdout
;
1941 lip
->li_slice_options
= options
;
1942 memcpy(lip
->li_name
, cmd
, i
);
1945 stdout
= new_stdout
;
1946 options
= new_options
;
1953 n_source_slice_hack_remove_after_jump(void){
1954 a_lex_unstack(FAL0
);
1958 n_source_may_yield_control(void){
1959 return ((options
& OPT_INTERACTIVE
) &&
1960 (pstate
& PS_STARTED
) &&
1961 (!(pstate
& PS_ROBOT
) ||
1962 /* But: ok for ~:, yet: unless in a hook.
1963 * TODO This is obviously hacky in that it depends on _input_stack not
1964 * TODO loosing any flags when creating new contexts... Maybe this
1965 * TODO function should instead walk all up the context stack when
1966 * TODO there is one, and verify neither level prevents yielding! */
1967 ((pstate
& PS_COMPOSE_MODE
) && (a_lex_input
== NULL
||
1968 !(a_lex_input
->li_flags
& a_LEX_SLICE
)))) &&
1969 (a_lex_input
== NULL
|| a_lex_input
->li_outer
== NULL
));