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 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
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 a_LEX_MACRO_X_OPTION
= 1<<4, /* Macro indeed command line -X option */
51 a_LEX_MACRO_CMD
= 1<<5, /* Macro indeed single-line: ~:COMMAND */
53 a_LEX_SUPER_MACRO
= 1<<16 /* *Not* inheriting PS_SOURCING state */
57 char const *lc_name
; /* Name of command */
58 int (*lc_func
)(void*); /* Implementor of command */
59 enum argtype lc_argtype
; /* Arglist type (see below) */
60 si16_t lc_msgflag
; /* Required flags of msgs */
61 si16_t lc_msgmask
; /* Relevant flags of msgs */
62 #ifdef HAVE_DOCSTRINGS
63 char const *lc_doc
; /* One line doc for command */
66 /* Yechh, can't initialize unions */
67 #define lc_minargs lc_msgflag /* Minimum argcount for RAWLIST */
68 #define lc_maxargs lc_msgmask /* Max argcount for RAWLIST */
71 struct a_lex_ghost
*lg_next
;
72 struct str lg_cmd
; /* Data follows after .lg_name */
73 char lg_name
[VFIELD_SIZE(0)];
76 struct a_lex_eval_ctx
{
77 struct str le_line
; /* The terminated data to _evaluate() */
78 ui32_t le_line_size
; /* May be used to store line memory size */
79 bool_t le_is_recursive
; /* Evaluation in evaluation? (collect ~:) */
81 bool_t le_add_history
; /* Enter (final) command in history? */
82 char const *le_new_content
; /* History: reenter line, start with this */
85 struct a_lex_input_stack
{
86 struct a_lex_input_stack
*li_outer
;
87 FILE *li_file
; /* File we were in */
88 void *li_cond
; /* Saved state of conditional stack */
89 ui32_t li_flags
; /* enum a_lex_input_flags */
90 ui32_t li_loff
; /* Pseudo (macro): index in .li_lines */
91 char **li_lines
; /* Pseudo content, lines unfolded */
92 char li_name
[VFIELD_SIZE(0)]; /* Name of file or macro */
95 static bool_t a_lex_reset_on_stop
; /* do a reset() if stopped */
96 static sighandler_type a_lex_oldpipe
;
97 static struct a_lex_ghost
*a_lex_ghosts
;
98 /* a_lex_cmd_tab[] after fun protos */
101 static struct a_lex_input_stack
*a_lex_input
;
103 /* Isolate the command from the arguments */
104 static char *a_lex_isolate(char const *comm
);
106 /* Command ghost handling */
107 static int a_lex_c_ghost(void *v
);
108 static int a_lex_c_unghost(void *v
);
110 /* Print a list of all commands */
111 static int a_lex_c_list(void *v
);
113 static int a_lex__pcmd_cmp(void const *s1
, void const *s2
);
116 static int a_lex_c_quit(void *v
);
118 /* Print the binaries compiled-in features */
119 static int a_lex_c_features(void *v
);
121 /* Print the binaries version number */
122 static int a_lex_c_version(void *v
);
124 /* PS_STATE_PENDMASK requires some actions */
125 static void a_lex_update_pstate(void);
127 /* Evaluate a single command.
128 * .le_add_history and .le_new_content will be updated upon success.
129 * Command functions return 0 for success, 1 for error, and -1 for abort.
130 * 1 or -1 aborts a load or source, a -1 aborts the interactive command loop */
131 static int a_lex_evaluate(struct a_lex_eval_ctx
*evp
);
133 /* Get first-fit, or NULL */
134 static struct a_lex_cmd
const *a_lex__firstfit(char const *comm
);
136 /* When we wake up after ^Z, reprint the prompt */
137 static void a_lex_stop(int s
);
139 /* Branch here on hangup signal and simulate "exit" */
140 static void a_lex_hangup(int s
);
142 /* The following gets called on receipt of an interrupt. Close all open files
143 * except 0, 1, 2, and the temporary. Also, unstack all source files */
144 static void a_lex_onintr(int s
);
146 /* Pop the current input back to the previous level. Update the program state.
147 * If the argument is TRUM1 then we don't alert and error out if the stack
148 * doesn't exist at all */
149 static void a_lex_unstack(bool_t eval_error
);
151 /* `source' and `source_if' (if silent_error: no pipes allowed, then) */
152 static bool_t
a_lex_source_file(char const *file
, bool_t silent_error
);
154 /* System resource file load()ing or -X command line option array traversal */
155 static bool_t
a_lex_load(struct a_lex_input_stack
*lip
);
157 /* A simplified command loop for recursed state machines */
158 static bool_t
a_commands_recursive(void);
160 /* List of all commands, and list of commands which are specially treated
161 * and deduced in _evaluate(), but we need a list for _c_list() and
162 * print_comm_docstr() */
163 #ifdef HAVE_DOCSTRINGS
168 static struct a_lex_cmd
const a_lex_cmd_tab
[] = {
171 a_lex_special_cmd_tab
[] = {
173 DS(N_("\"Comment command\": ignore remaining (continuable) line")) },
175 DS(N_("Print out the preceding message")) }
180 a_lex_isolate(char const *comm
){
182 while(*comm
!= '\0' &&
183 strchr("~|? \t0123456789&%@$^.:/-+*'\",;(`", *comm
) == NULL
)
186 return UNCONST(comm
);
190 a_lex_c_ghost(void *v
){
191 struct a_lex_ghost
*lgp
, *gp
;
203 if((fp
= Ftmp(NULL
, "ghost", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
)
206 for(i
= 0, gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
207 fprintf(fp
, "wysh ghost %s %s\n",
208 gp
->lg_name
, n_shell_quote_cp(gp
->lg_cmd
.s
, TRU1
));
211 page_or_print(fp
, i
);
217 /* Verify the ghost name is a valid one */
218 if(*argv
[0] == '\0' || *a_lex_isolate(argv
[0]) != '\0'){
219 n_err(_("`ghost': can't canonicalize \"%s\"\n"), argv
[0]);
224 /* Show command of single ghost? */
226 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
227 if(!strcmp(argv
[0], gp
->lg_name
)){
228 printf("wysh ghost %s %s\n",
229 gp
->lg_name
, n_shell_quote_cp(gp
->lg_cmd
.s
, TRU1
));
232 n_err(_("`ghost': no such alias: \"%s\"\n"), argv
[0]);
237 /* Define command for ghost: verify command content */
238 for(cl
= 0, i
= 1; (cp
= UNCONST(argv
[i
])) != NULL
; ++i
)
240 cl
+= strlen(cp
) +1; /* SP or NUL */
242 n_err(_("`ghost': empty command arguments after \"%s\"\n"), argv
[0]);
247 /* If the ghost already exists, recreate */
248 for(lgp
= NULL
, gp
= a_lex_ghosts
; gp
!= NULL
; lgp
= gp
, gp
= gp
->lg_next
)
249 if(!strcmp(gp
->lg_name
, argv
[0])){
251 lgp
->lg_next
= gp
->lg_next
;
253 a_lex_ghosts
= gp
->lg_next
;
258 nl
= strlen(argv
[0]) +1;
259 gp
= smalloc(sizeof(*gp
) - VFIELD_SIZEOF(struct a_lex_ghost
, lg_name
) +
261 gp
->lg_next
= a_lex_ghosts
;
263 memcpy(gp
->lg_name
, argv
[0], nl
);
264 cp
= gp
->lg_cmd
.s
= gp
->lg_name
+ nl
;
267 while(*++argv
!= NULL
)
268 if((i
= strlen(*argv
)) > 0){
269 memcpy(cp
, *argv
, i
);
280 a_lex_c_unghost(void *v
){
281 struct a_lex_ghost
*lgp
, *gp
;
282 char const **argv
, *cp
;
289 while((cp
= *argv
++) != NULL
){
290 if(cp
[0] == '*' && cp
[1] == '\0'){
291 while((gp
= a_lex_ghosts
) != NULL
){
292 a_lex_ghosts
= gp
->lg_next
;
296 for(lgp
= NULL
, gp
= a_lex_ghosts
; gp
!= NULL
;
297 lgp
= gp
, gp
= gp
->lg_next
)
298 if(!strcmp(gp
->lg_name
, cp
)){
300 lgp
->lg_next
= gp
->lg_next
;
302 a_lex_ghosts
= gp
->lg_next
;
306 n_err(_("`unghost': no such alias: \"%s\"\n"), cp
);
316 a_lex_c_list(void *v
){
317 struct a_lex_cmd
const **cpa
, *cp
, **cursor
;
321 i
= NELEM(a_lex_cmd_tab
) + NELEM(a_lex_special_cmd_tab
) +1;
322 cpa
= salloc(sizeof(cp
) * i
);
324 for(i
= 0; i
< NELEM(a_lex_cmd_tab
); ++i
)
325 cpa
[i
] = &a_lex_cmd_tab
[i
];
329 for(j
= 0; j
< NELEM(a_lex_special_cmd_tab
); ++i
, ++j
)
330 cpa
[i
] = &a_lex_special_cmd_tab
[j
];
338 qsort(cpa
, i
, sizeof(xcp
), &a_lex__pcmd_cmp
);
341 printf(_("Commands are:\n"));
342 for(i
= 0, cursor
= cpa
; (cp
= *cursor
++) != NULL
;){
345 if(cp
->lc_func
== &c_cmdnotsupp
)
347 j
= strlen(cp
->lc_name
) + 2;
352 printf((*cursor
!= NULL
? "%s, " : "%s\n"), cp
->lc_name
);
359 a_lex__pcmd_cmp(void const *s1
, void const *s2
){
360 struct a_lex_cmd
const * const *cp1
, * const *cp2
;
366 rv
= strcmp((*cp1
)->lc_name
, (*cp2
)->lc_name
);
372 a_lex_c_quit(void *v
){
376 /* If we are PS_SOURCING, then return 1 so _evaluate() can handle it.
377 * Otherwise return -1 to abort command loop */
384 a_lex_c_features(void *v
){
389 printf(_("Features: %s\n"), ok_vlook(features
));
395 a_lex_c_version(void *v
){
400 printf(_("Version %s\n"), ok_vlook(version
));
406 a_lex_update_pstate(void){
409 if(pstate
& PS_SIGWINCH_PEND
){
412 snprintf(buf
, sizeof buf
, "%d", scrnwidth
);
413 ok_vset(COLUMNS
, buf
);
414 snprintf(buf
, sizeof buf
, "%d", scrnheight
);
418 pstate
&= ~PS_PSTATE_PENDMASK
;
423 a_lex_evaluate(struct a_lex_eval_ctx
*evp
){
424 /* xxx old style(9), but also old code */
426 char _wordbuf
[2], *arglist
[MAXARGC
], *cp
, *word
;
427 struct a_lex_ghost
*gp
;
428 struct a_lex_cmd
const *cmd
;
437 line
= evp
->le_line
; /* XXX don't change original (buffer pointer) */
438 assert(line
.s
[line
.l
] == '\0');
439 evp
->le_add_history
= FAL0
;
440 evp
->le_new_content
= NULL
;
442 /* Command ghosts that refer to shell commands or macro expansion restart */
445 /* Strip the white space away from end and beginning of command */
449 for(cp
= &line
.s
[i
-1]; spacechar(*cp
); --cp
)
453 for(cp
= line
.s
; spacechar(*cp
); ++cp
)
455 line
.l
-= PTR2SIZE(cp
- line
.s
);
457 /* Ignore null commands (comments) */
461 /* Handle ! differently to get the correct lexical conventions */
465 /* Isolate the actual command; since it may not necessarily be
466 * separated from the arguments (as in `p1') we need to duplicate it to
467 * be able to create a NUL terminated version.
468 * We must be aware of several special one letter commands here */
469 else if((cp
= a_lex_isolate(cp
)) == arglist
[0] &&
470 (*cp
== '|' || *cp
== '~' || *cp
== '?'))
472 c
= (int)PTR2SIZE(cp
- arglist
[0]);
474 word
= UICMP(z
, c
, <, sizeof _wordbuf
) ? _wordbuf
: salloc(c
+1);
475 memcpy(word
, arglist
[0], c
);
478 /* Look up the command; if not found, bitch.
479 * Normally, a blank command would map to the first command in the
480 * table; while PS_SOURCING, however, we ignore blank lines to eliminate
481 * confusion; act just the same for ghosts */
483 if((pstate
& PS_ROBOT
) || gp
!= NULL
)
485 cmd
= a_lex_cmd_tab
+ 0;
489 /* XXX It may be the argument parse adjuster */
490 if(!wysh
&& c
== sizeof("wysh") -1 && !asccasecmp(word
, "wysh")){
496 /* If this is the first evaluation, check command ghosts */
498 /* TODO relink list head, so it's sorted on usage over time?
499 * TODO in fact, there should be one hashmap over all commands and ghosts
500 * TODO so that the lookup could be made much more efficient than it is
501 * TODO now (two adjacent list searches! */
502 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
503 if(!strcmp(word
, gp
->lg_name
)){
508 line
.s
= salloc(i
+ line
.l
+1);
509 memcpy(line
.s
, gp
->lg_cmd
.s
, i
);
510 memcpy(line
.s
+ i
, cp
, line
.l
);
511 line
.s
[i
+= line
.l
] = '\0';
514 line
.s
= gp
->lg_cmd
.s
;
515 line
.l
= gp
->lg_cmd
.l
;
521 if((cmd
= a_lex__firstfit(word
)) == NULL
|| cmd
->lc_func
== &c_cmdnotsupp
){
524 if(!(s
= condstack_isskip()) || (options
& OPT_D_V
))
525 n_err(_("Unknown command%s: `%s'\n"),
526 (s
? _(" (ignored due to `if' condition)") : ""), word
);
536 /* See if we should execute the command -- if a conditional we always
537 * execute it, otherwise, check the state of cond */
539 if(!(cmd
->lc_argtype
& ARG_F
) && condstack_isskip())
542 /* Process the arguments to the command, depending on the type it expects */
543 if(!(cmd
->lc_argtype
& ARG_M
) && (options
& OPT_SENDMODE
)){
544 n_err(_("May not execute `%s' while sending\n"), cmd
->lc_name
);
547 if((cmd
->lc_argtype
& ARG_S
) && !(pstate
& PS_STARTED
)){
548 n_err(_("May not execute `%s' during startup\n"), cmd
->lc_name
);
551 if((cmd
->lc_argtype
& ARG_I
) &&
552 !(options
& (OPT_INTERACTIVE
| OPT_BATCH_FLAG
))){
553 n_err(_("May not execute `%s' unless interactive or in batch mode\n"),
557 if((cmd
->lc_argtype
& ARG_R
) && (pstate
& PS_RECURSED
)){
558 n_err(_("Cannot invoke `%s' when in recursed mode (e.g., composing)\n"),
563 if((cmd
->lc_argtype
& ARG_W
) && !(mb
.mb_perm
& MB_DELE
)){
564 n_err(_("May not execute `%s' -- message file is read only\n"),
568 if((cmd
->lc_argtype
& ARG_A
) && mb
.mb_type
== MB_VOID
){
569 n_err(_("Cannot execute `%s' without active mailbox\n"), cmd
->lc_name
);
573 if(cmd
->lc_argtype
& ARG_O
)
574 OBSOLETE2(_("this command will be removed"), cmd
->lc_name
);
575 if(cmd
->lc_argtype
& ARG_V
)
576 temporary_arg_v_store
= NULL
;
578 if(wysh
&& (cmd
->lc_argtype
& ARG_ARGMASK
) != ARG_WYRALIST
)
579 n_err(_("`wysh' prefix doesn't affect `%s'\n"), cmd
->lc_name
);
580 switch(cmd
->lc_argtype
& ARG_ARGMASK
){
582 /* Message list defaulting to nearest forward legal message */
585 if((c
= getmsglist(cp
, n_msgvec
, cmd
->lc_msgflag
)) < 0)
588 if((n_msgvec
[0] = first(cmd
->lc_msgflag
, cmd
->lc_msgmask
)) != 0)
591 if(n_msgvec
[0] == 0){
592 if(!(pstate
& PS_HOOK_MASK
))
593 printf(_("No applicable messages\n"));
596 e
= (*cmd
->lc_func
)(n_msgvec
);
600 /* Message list with no defaults, but no error if none exist */
601 if(n_msgvec
== NULL
){
603 n_err(_("Invalid use of \"message list\"\n"));
606 if((c
= getmsglist(cp
, n_msgvec
, cmd
->lc_msgflag
)) < 0)
608 e
= (*cmd
->lc_func
)(n_msgvec
);
612 /* Just the straight string, with leading blanks removed */
613 while(whitechar(*cp
))
615 e
= (*cmd
->lc_func
)(cp
);
630 if((c
= getrawlist((c
!= 0), arglist
, NELEM(arglist
), cp
, line
.l
)) < 0){
631 n_err(_("Invalid argument list\n"));
634 if(c
< cmd
->lc_minargs
){
635 n_err(_("`%s' requires at least %d arg(s)\n"),
636 cmd
->lc_name
, cmd
->lc_minargs
);
640 if(c
> cmd
->lc_maxargs
){
641 n_err(_("`%s' takes no more than %d arg(s)\n"),
642 cmd
->lc_name
, cmd
->lc_maxargs
);
646 e
= (*cmd
->lc_func
)(arglist
);
650 /* Just the constant zero, for exiting, eg. */
651 e
= (*cmd
->lc_func
)(0);
655 DBG( n_panic(_("Implementation error: unknown argument type: %d"),
656 cmd
->lc_argtype
& ARG_ARGMASK
); )
660 if(e
== 0 && (cmd
->lc_argtype
& ARG_V
) &&
661 (cp
= temporary_arg_v_store
) != NULL
){
662 temporary_arg_v_store
= NULL
;
663 evp
->le_new_content
= cp
;
666 if(!(cmd
->lc_argtype
& ARG_H
) && !(pstate
& PS_MSGLIST_SAW_NO
))
667 evp
->le_add_history
= TRU1
;
670 /* Exit the current source file on error TODO what a mess! */
672 pstate
&= ~PS_EVAL_ERROR
;
674 pstate
|= PS_EVAL_ERROR
;
675 if(e
< 0 || (pstate
& PS_ROBOT
)){ /* FIXME */
684 if((cmd
->lc_argtype
& ARG_P
) && ok_blook(autoprint
))
686 line
.s
= savestr("type");
687 line
.l
= sizeof("type") -1;
688 gp
= (struct a_lex_ghost
*)-1; /* Avoid `ghost' interpretation */
692 if(!(pstate
& (PS_SOURCING
| PS_HOOK_MASK
)) && !(cmd
->lc_argtype
& ARG_T
))
693 pstate
|= PS_SAW_COMMAND
;
695 pstate
&= ~PS_EVAL_ERROR
;
700 fprintf(stderr, "a_lex_evaluate returns %d for <%s>\n",e,line.s);
706 static struct a_lex_cmd
const *
707 a_lex__firstfit(char const *comm
){ /* TODO *hashtable*! linear list search!!! */
708 struct a_lex_cmd
const *cp
;
711 for(cp
= a_lex_cmd_tab
; PTRCMP(cp
, <, &a_lex_cmd_tab
[NELEM(a_lex_cmd_tab
)]);
713 if(*comm
== *cp
->lc_name
&& is_prefix(comm
, cp
->lc_name
))
723 sighandler_type old_action
;
725 NYD_X
; /* Signal handler */
727 old_action
= safe_signal(s
, SIG_DFL
);
731 sigprocmask(SIG_UNBLOCK
, &nset
, NULL
);
733 sigprocmask(SIG_BLOCK
, &nset
, NULL
);
735 safe_signal(s
, old_action
);
737 if(a_lex_reset_on_stop
){
738 a_lex_reset_on_stop
= 0;
739 n_TERMCAP_RESUME(TRU1
);
740 siglongjmp(srbuf
, 0); /* FIXME get rid */
746 NYD_X
; /* Signal handler */
754 NYD_X
; /* Signal handler */
756 safe_signal(SIGINT
, a_lex_onintr
);
758 a_lex_unstack(TRUM1
);
760 termios_state_reset();
761 close_all_files(); /* FIXME .. to outer level ONLU! */
768 n_err_sighdl(_("Interrupt\n"));
769 safe_signal(SIGPIPE
, a_lex_oldpipe
);
770 siglongjmp(srbuf
, 0); /* FIXME get rid */
774 a_lex_unstack(bool_t eval_error
){
775 struct a_lex_input_stack
*lip
;
778 if((lip
= a_lex_input
) == NULL
){
779 /* If called from a_lex_onintr(), be silent FIXME */
780 pstate
&= ~(PS_SOURCING
| PS_ROBOT
);
781 if(eval_error
== TRUM1
|| !(pstate
& PS_STARTED
))
786 if(lip
->li_flags
& a_LEX_MACRO
){
787 if(lip
->li_flags
& a_LEX_MACRO_FREE_DATA
){
790 while(*(lp
= &lip
->li_lines
[lip
->li_loff
]) != NULL
){
794 /* Part of lip's memory chunk, then */
795 if(!(lip
->li_flags
& a_LEX_MACRO_CMD
))
799 if(lip
->li_flags
& a_LEX_PIPE
)
800 /* XXX command manager should -TERM then -KILL instead of hoping
801 * XXX for exit of provider due to EPIPE / SIGPIPE */
802 Pclose(lip
->li_file
, TRU1
);
804 Fclose(lip
->li_file
);
807 if(!condstack_take(lip
->li_cond
)){
808 n_err(_("Unmatched `if' at end of %s \"%s\"\n"),
809 ((lip
->li_flags
& a_LEX_MACRO
810 ? (lip
->li_flags
& a_LEX_MACRO_CMD
? _("command") : _("macro"))
811 : _("`source'd file"))),
816 if((a_lex_input
= lip
->li_outer
) == NULL
){
817 pstate
&= ~(PS_SOURCING
| PS_ROBOT
);
819 if((a_lex_input
->li_flags
& (a_LEX_MACRO
| a_LEX_SUPER_MACRO
)) ==
820 (a_LEX_MACRO
| a_LEX_SUPER_MACRO
))
821 pstate
&= ~PS_SOURCING
;
822 assert(pstate
& PS_ROBOT
);
827 if(lip
->li_flags
& a_LEX_FREE
)
830 if(UNLIKELY(a_lex_input
!= NULL
&& eval_error
== TRUM1
))
831 a_lex_unstack(TRUM1
);
837 if(options
& OPT_D_V
)
838 n_alert(_("Stopped %s \"%s\" due to errors%s"),
840 ? (lip
->li_flags
& a_LEX_MACRO
841 ? (lip
->li_flags
& a_LEX_MACRO_CMD
842 ? _("evaluating command") : _("evaluating macro"))
843 : (lip
->li_flags
& a_LEX_PIPE
844 ? _("executing `source'd pipe")
845 : _("loading `source'd file")))
846 : (lip
->li_flags
& a_LEX_MACRO
847 ? (lip
->li_flags
& a_LEX_MACRO_X_OPTION
848 ? _("evaluating command line") : _("evaluating macro"))
849 : _("loading initialization resource"))),
851 (options
& OPT_DEBUG
? "" : _(" (enable *debug* for trace)")));
852 if(lip
->li_flags
& a_LEX_FREE
)
856 if(!(options
& OPT_INTERACTIVE
) && !(pstate
& PS_STARTED
)){
857 if(options
& OPT_D_V
)
858 n_alert(_("Non-interactive, bailing out due to errors "
859 "in startup load phase"));
866 a_lex_source_file(char const *file
, bool_t silent_error
){
867 struct a_lex_input_stack
*lip
;
876 /* Being a command argument file is space-trimmed */
877 if((ispipe
= (!silent_error
&& (nlen
= strlen(file
)) > 0 &&
878 file
[--nlen
] == '|'))){
879 if((fip
= Popen(nbuf
= savestrbuf(file
, nlen
), "r",
880 ok_vlook(SHELL
), NULL
, COMMAND_FD_NULL
)) == NULL
){
881 if(!silent_error
|| (options
& OPT_D_V
))
885 }else if((nbuf
= fexpand(file
, FEXP_LOCAL
)) == NULL
)
887 else if((fip
= Fopen(nbuf
, "r")) == NULL
){
888 if(!silent_error
|| (options
& OPT_D_V
))
893 lip
= smalloc(sizeof(*lip
) -
894 VFIELD_SIZEOF(struct a_lex_input_stack
, li_name
) +
895 (nlen
= strlen(nbuf
) +1));
896 lip
->li_outer
= a_lex_input
;
898 lip
->li_cond
= condstack_release();
899 lip
->li_flags
= (ispipe
? a_LEX_PIPE
: a_LEX_NONE
) |
900 (a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
901 ? a_LEX_SUPER_MACRO
: 0);
902 memcpy(lip
->li_name
, nbuf
, nlen
);
904 pstate
|= PS_SOURCING
| PS_ROBOT
;
906 a_commands_recursive();
907 /* FIXME return TRUM1 if file can't be opened, FAL0 on eval error */
910 return silent_error
? TRU1
: (fip
!= NULL
);
914 a_lex_load(struct a_lex_input_stack
*lip
){
918 assert(!(pstate
& PS_STARTED
));
919 assert(a_lex_input
== NULL
);
922 * Any errors in the start-up file shall either cause mailx to terminate
923 * with a diagnostic message and a non-zero status or to continue after
924 * writing a diagnostic message, ignoring the remainder of the lines in
925 * the start-up file. */
926 lip
->li_cond
= condstack_release();
928 /* FIXME won't work for now (PS_ROBOT needs PS_SOURCING anyway)
930 (lip->li_flags & a_LEX_MACRO_X_OPTION ? 0 : PS_SOURCING);
932 pstate
|= PS_ROBOT
| PS_SOURCING
;
933 if(options
& OPT_D_V
)
934 n_err(_("Loading \"%s\"\n"), lip
->li_name
);
936 if(!(rv
= n_commands())){
937 if(!(options
& OPT_INTERACTIVE
)){
938 if(options
& OPT_D_V
)
939 n_alert(_("Non-interactive program mode, forced exit"));
943 /* PS_EXIT handled by callers */
949 a_commands_recursive(void){
950 struct a_lex_eval_ctx ev
;
954 memset(&ev
, 0, sizeof ev
);
956 /* FIXME sigkondom */
957 n_COLOUR( n_colour_env_push(); )
962 /* Read a line of commands and handle end of file specially */
963 ev
.le_line
.l
= ev
.le_line_size
;
964 n
= n_lex_input(NULL
, TRU1
, &ev
.le_line
.s
, &ev
.le_line
.l
,
966 ev
.le_line_size
= (ui32_t
)ev
.le_line
.l
;
967 ev
.le_line
.l
= (ui32_t
)n
;
972 if(a_lex_evaluate(&ev
)){
977 if((options
& OPT_BATCH_FLAG
) && ok_blook(batch_exit_on_error
)){
978 if(exit_status
!= EXIT_OK
)
983 n_COLOUR( n_colour_env_pop(FAL0
); )
985 if(ev
.le_line
.s
!= NULL
)
991 #ifdef HAVE_DOCSTRINGS
993 n_print_comm_docstr(char const *comm
){
994 struct a_lex_ghost
const *gp
;
995 struct a_lex_cmd
const *cp
, *cpmax
;
999 /* Ghosts take precedence */
1000 for(gp
= a_lex_ghosts
; gp
!= NULL
; gp
= gp
->lg_next
)
1001 if(!strcmp(comm
, gp
->lg_name
)){
1002 printf("%s -> ", comm
);
1003 comm
= gp
->lg_cmd
.s
;
1007 cpmax
= &(cp
= a_lex_cmd_tab
)[NELEM(a_lex_cmd_tab
)];
1009 for(; PTRCMP(cp
, <, cpmax
); ++cp
){
1010 if(!strcmp(comm
, cp
->lc_name
))
1011 printf("%s: %s\n", comm
, V_(cp
->lc_doc
));
1012 else if(is_prefix(comm
, cp
->lc_name
))
1013 printf("%s (%s): %s\n", comm
, cp
->lc_name
, V_(cp
->lc_doc
));
1019 if(!rv
&& PTRCMP(cpmax
, ==, &a_lex_cmd_tab
[NELEM(a_lex_cmd_tab
)])){
1020 cpmax
= &(cp
= a_lex_special_cmd_tab
)[NELEM(a_lex_special_cmd_tab
)];
1024 if(!rv
&& gp
!= NULL
){
1025 printf("\"%s\"\n", comm
);
1031 #endif /* HAVE_DOCSTRINGS */
1034 n_commands(void){ /* FIXME */
1035 struct a_lex_eval_ctx ev
;
1037 bool_t
volatile rv
= TRU1
;
1040 if (!(pstate
& PS_SOURCING
)) {
1041 if (safe_signal(SIGINT
, SIG_IGN
) != SIG_IGN
)
1042 safe_signal(SIGINT
, &a_lex_onintr
);
1043 if (safe_signal(SIGHUP
, SIG_IGN
) != SIG_IGN
)
1044 safe_signal(SIGHUP
, &a_lex_hangup
);
1045 /* TODO We do a lot of redundant signal handling, especially
1046 * TODO with the command line editor(s); try to merge this */
1047 safe_signal(SIGTSTP
, &a_lex_stop
);
1048 safe_signal(SIGTTOU
, &a_lex_stop
);
1049 safe_signal(SIGTTIN
, &a_lex_stop
);
1051 a_lex_oldpipe
= safe_signal(SIGPIPE
, SIG_IGN
);
1052 safe_signal(SIGPIPE
, a_lex_oldpipe
);
1054 memset(&ev
, 0, sizeof ev
);
1056 (void)sigsetjmp(srbuf
, 1); /* FIXME get rid */
1058 char *temporary_orig_line
; /* XXX eval_ctx.le_line not yet constant */
1060 n_COLOUR( n_colour_env_pop(TRU1
); )
1062 /* TODO Unless we have our signal manager (or however we do it) child
1063 * TODO processes may have time slots where their execution isn't
1064 * TODO protected by signal handlers (in between start and setup
1065 * TODO completed). close_all_files() is only called from onintr()
1066 * TODO so those may linger possibly forever */
1067 if(!(pstate
& PS_SOURCING
))
1072 temporary_localopts_free(); /* XXX intermediate hack */
1073 sreset((pstate
& PS_SOURCING
) != 0);
1074 if (!(pstate
& PS_SOURCING
)) {
1077 /* TODO Note: this buffer may contain a password. We should redefine
1078 * TODO the code flow which has to do that */
1079 if ((cp
= termios_state
.ts_linebuf
) != NULL
) {
1080 termios_state
.ts_linebuf
= NULL
;
1081 termios_state
.ts_linesize
= 0;
1082 free(cp
); /* TODO pool give-back */
1084 /* TODO Due to expand-on-tab of NCL the buffer may grow */
1085 if (ev
.le_line
.l
> LINESIZE
* 3) {
1086 free(ev
.le_line
.s
); /* TODO pool! but what? */
1087 ev
.le_line
.s
= NULL
;
1088 ev
.le_line
.l
= ev
.le_line_size
= 0;
1092 if (!(pstate
& PS_SOURCING
) && (options
& OPT_INTERACTIVE
)) {
1095 cp
= ok_vlook(newmail
);
1096 if ((options
& OPT_TTYIN
) && cp
!= NULL
) {
1099 /* FIXME TEST WITH NOPOLL ETC. !!! */
1100 n
= (cp
!= NULL
&& strcmp(cp
, "nopoll"));
1101 if ((mb
.mb_type
== MB_FILE
&& !stat(mailname
, &st
) &&
1102 st
.st_size
> mailsize
) ||
1103 (mb
.mb_type
== MB_MAILDIR
&& n
!= 0)) {
1104 size_t odot
= PTR2SIZE(dot
- message
);
1105 ui32_t odid
= (pstate
& PS_DID_PRINT_DOT
);
1107 if (setfile(mailname
,
1109 ((mb
.mb_perm
& MB_DELE
) ? 0 : FEDIT_RDONLY
)) < 0) {
1110 exit_status
|= EXIT_ERR
;
1114 dot
= message
+ odot
;
1119 a_lex_reset_on_stop
= TRU1
;
1120 exit_status
= EXIT_OK
;
1123 /* Read a line of commands and handle end of file specially */
1125 ev
.le_line
.l
= ev
.le_line_size
;
1126 n
= n_lex_input(NULL
, TRU1
, &ev
.le_line
.s
, &ev
.le_line
.l
,
1128 ev
.le_line_size
= (ui32_t
)ev
.le_line
.l
;
1129 ev
.le_line
.l
= (ui32_t
)n
;
1130 a_lex_reset_on_stop
= FAL0
;
1133 /* FIXME did unstack() when PS_SOURCING, only break with PS_LOADING*/
1134 if (!(pstate
& PS_ROBOT
) &&
1135 (options
& OPT_INTERACTIVE
) && ok_blook(ignoreeof
)) {
1136 printf(_("*ignoreeof* set, use `quit' to quit.\n"));
1137 n_msleep(500, FAL0
);
1143 temporary_orig_line
= ((pstate
& PS_SOURCING
) ||
1144 !(options
& OPT_INTERACTIVE
)) ? NULL
1145 : savestrbuf(ev
.le_line
.s
, ev
.le_line
.l
);
1146 pstate
&= ~PS_HOOK_MASK
;
1147 if (a_lex_evaluate(&ev
)) {
1148 if (!(pstate
& PS_STARTED
)) /* TODO mess; join PS_EVAL_ERROR.. */
1153 if ((options
& OPT_BATCH_FLAG
) && ok_blook(batch_exit_on_error
)) {
1154 if (exit_status
!= EXIT_OK
)
1156 if ((pstate
& (PS_SOURCING
| PS_EVAL_ERROR
)) == PS_EVAL_ERROR
) {
1157 exit_status
= EXIT_ERR
;
1161 if (!(pstate
& PS_SOURCING
) && (options
& OPT_INTERACTIVE
)) {
1162 if (ev
.le_new_content
!= NULL
)
1164 /* *Can* happen since _evaluate() n_unstack()s on error! XXX no more */
1165 if (temporary_orig_line
!= NULL
)
1166 n_tty_addhist(temporary_orig_line
, !ev
.le_add_history
);
1169 if(pstate
& PS_EXIT
)
1174 if (ev
.le_line
.s
!= NULL
)
1176 if (pstate
& PS_SOURCING
)
1183 (n_lex_input
)(char const *prompt
, bool_t nl_escape
, char **linebuf
,
1184 size_t *linesize
, char const *string SMALLOC_DEBUG_ARGS
){
1185 /* TODO readline: linebuf pool! */
1186 bool_t doprompt
, dotty
;
1191 /* Special case macro mode: never need to prompt, lines have always been
1192 * unfolded already */
1193 if(a_lex_input
!= NULL
&& (a_lex_input
->li_flags
& a_LEX_MACRO
)){
1194 char **lp
= &a_lex_input
->li_lines
[a_lex_input
->li_loff
];
1196 if(*linebuf
!= NULL
)
1199 if((*linebuf
= *lp
) == NULL
){
1203 ++a_lex_input
->li_loff
;
1204 n
= (int)(*linesize
= strlen(*linebuf
));
1206 if(!(a_lex_input
->li_flags
& a_LEX_MACRO_FREE_DATA
))
1207 *linebuf
= sbufdup(*linebuf
, *linesize
);
1209 if(options
& OPT_D_VV
)
1210 n_err(_("%s %d bytes <%.*s>\n"),
1211 (a_lex_input
->li_flags
& a_LEX_MACRO_X_OPTION
1212 ? _("-X option") : _("MACRO")),
1218 doprompt
= ((pstate
& (PS_STARTED
| PS_ROBOT
)) == PS_STARTED
&&
1219 (options
& OPT_INTERACTIVE
));
1220 dotty
= (doprompt
&& !ok_blook(line_editor_disable
));
1223 else if(prompt
== NULL
)
1224 prompt
= getprompt();
1226 /* Ensure stdout is flushed first anyway */
1227 if(!dotty
&& prompt
== NULL
)
1230 ifile
= (a_lex_input
!= NULL
) ? a_lex_input
->li_file
: stdin
;
1231 assert(ifile
!= NULL
);
1233 for(nold
= n
= 0;;){
1235 assert(ifile
== stdin
);
1236 if(string
!= NULL
&& (n
= (int)strlen(string
)) > 0){
1240 *linesize
= (size_t)n
+ LINESIZE
+1;
1241 *linebuf
= (srealloc
)(*linebuf
, *linesize SMALLOC_DEBUG_ARGSCALL
);
1242 memcpy(*linebuf
, string
, (size_t)n
+1);
1245 /* TODO if nold>0, don't redisplay the entire line!
1246 * TODO needs complete redesign ... */
1247 n
= (n_tty_readline
)(prompt
, linebuf
, linesize
, n
1248 SMALLOC_DEBUG_ARGSCALL
);
1250 if(prompt
!= NULL
) {
1252 fputs(prompt
, stdout
);
1256 n
= (readline_restart
)(ifile
, linebuf
, linesize
, n
1257 SMALLOC_DEBUG_ARGSCALL
);
1259 if(n
> 0 && nold
> 0){
1261 char const *cp
= *linebuf
+ nold
;
1263 while(blankspacechar(*cp
) && nold
+ i
< n
)
1266 memmove(*linebuf
+ nold
, cp
, n
- nold
- i
);
1268 (*linebuf
)[n
] = '\0';
1277 * An unquoted <backslash> at the end of a command line shall
1278 * be discarded and the next line shall continue the command */
1279 if(!nl_escape
|| (*linebuf
)[n
- 1] != '\\')
1281 /* Definitely outside of quotes, thus the quoting rules are so that an
1282 * uneven number of successive backslashs at EOL is a continuation */
1286 for(j
= 1, i
= (size_t)n
- 1; i
-- > 0; ++j
)
1287 if((*linebuf
)[i
] != '\\')
1292 (*linebuf
)[nold
= --n
] = '\0';
1293 if(prompt
!= NULL
&& *prompt
!= '\0')
1294 prompt
= ".. "; /* XXX PS2 .. */
1298 (*linebuf
)[*linesize
= n
] = '\0';
1300 if(options
& OPT_D_VV
)
1301 n_err(_("%s %d bytes <%.*s>\n"),
1302 (!(pstate
& PS_STARTED
) ? "LOAD"
1303 : (pstate
& PS_SOURCING
? "SOURCE" : "READ")),
1307 if (pstate
& PS_PSTATE_PENDMASK
)
1308 a_lex_update_pstate();
1315 n_lex_input_cp_addhist(char const *prompt
, char const *string
, bool_t isgabby
){
1316 /* FIXME n_lex_input_cp_addhist(): leaks on sigjmp without linepool */
1326 n
= n_lex_input(prompt
, TRU1
, &linebuf
, &linesize
, string
);
1327 if(n
> 0 && *(rv
= savestrbuf(linebuf
, (size_t)n
)) != '\0' &&
1328 (options
& OPT_INTERACTIVE
))
1329 n_tty_addhist(rv
, isgabby
);
1338 n_load(char const *name
){
1339 struct a_lex_input_stack
*lip
;
1344 if(name
== NULL
|| *name
== '\0' || (fip
= Fopen(name
, "r")) == NULL
)
1347 i
= strlen(name
) +1;
1348 lip
= scalloc(1, sizeof(*lip
) -
1349 VFIELD_SIZEOF(struct a_lex_input_stack
, li_name
) + i
);
1351 lip
->li_flags
= a_LEX_FREE
;
1352 memcpy(lip
->li_name
, name
, i
);
1361 n_load_Xargs(char const **lines
){
1362 static char const name
[] = "-X";
1364 ui8_t buf
[sizeof(struct a_lex_input_stack
) + sizeof name
];
1365 struct a_lex_input_stack
*lip
;
1368 memset(buf
, 0, sizeof buf
);
1370 lip
->li_flags
= a_LEX_MACRO
| a_LEX_MACRO_X_OPTION
| a_LEX_SUPER_MACRO
;
1371 lip
->li_lines
= UNCONST(lines
);
1372 memcpy(lip
->li_name
, name
, sizeof name
);
1375 if(pstate
& PS_EXIT
)
1385 rv
= (a_lex_source_file(*(char**)v
, FAL0
) == TRU1
) ? 0 : 1;
1391 c_source_if(void *v
){ /* XXX obsolete?, support file tests in `if' etc.! */
1395 rv
= (a_lex_source_file(*(char**)v
, TRU1
) != FAL0
) ? 0 : 1;
1401 n_source_macro(char const *name
, char **lines
){
1402 struct a_lex_input_stack
*lip
;
1407 lip
= smalloc(sizeof(*lip
) -
1408 VFIELD_SIZEOF(struct a_lex_input_stack
, li_name
) +
1409 (i
= strlen(name
) +1));
1410 lip
->li_outer
= a_lex_input
;
1411 lip
->li_file
= NULL
;
1412 lip
->li_cond
= condstack_release();
1413 lip
->li_flags
= a_LEX_FREE
| a_LEX_MACRO
| a_LEX_MACRO_FREE_DATA
|
1414 (a_lex_input
== NULL
|| (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
1415 ? a_LEX_SUPER_MACRO
: 0);
1417 lip
->li_lines
= lines
;
1418 memcpy(lip
->li_name
, name
, i
);
1422 rv
= a_commands_recursive();
1428 n_source_command(char const *cmd
){
1429 struct a_lex_input_stack
*lip
;
1435 cmd
= sbufdup(cmd
, i
++);
1438 lip
= smalloc(sizeof(*lip
) -
1439 VFIELD_SIZEOF(struct a_lex_input_stack
, li_name
) +
1440 ial
+ 2*sizeof(char*));
1441 lip
->li_outer
= a_lex_input
;
1442 lip
->li_file
= NULL
;
1443 lip
->li_cond
= condstack_release();
1444 lip
->li_flags
= a_LEX_FREE
| a_LEX_MACRO
| a_LEX_MACRO_FREE_DATA
|
1446 (a_lex_input
== NULL
|| (a_lex_input
->li_flags
& a_LEX_SUPER_MACRO
)
1447 ? a_LEX_SUPER_MACRO
: 0);
1449 lip
->li_lines
= (void*)(lip
->li_name
+ ial
);
1450 lip
->li_lines
[0] = UNCONST(cmd
); /* dup'ed above */
1451 lip
->li_lines
[1] = NULL
;
1452 memcpy(lip
->li_name
, cmd
, i
);
1456 rv
= a_commands_recursive();
1462 n_source_may_yield_control(void){
1463 return ((options
& OPT_INTERACTIVE
) &&
1464 (pstate
& PS_STARTED
) &&
1465 (!(pstate
& PS_ROBOT
) || (pstate
& PS_RECURSED
)) && /* Ok for ~: */
1466 (a_lex_input
== NULL
|| a_lex_input
->li_outer
== NULL
));