THANKS: v14.7.3
[s-mailx.git] / lex.c
blob7b27aa11642c8badb24274089447d08a058d740e
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ (Lexical processing of) Commands, and the (blocking) "event mainloop".
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
6 */
7 /*
8 * Copyright (c) 1980, 1993
9 * The Regents of the University of California. All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the University of
22 * California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
40 #ifndef HAVE_AMALGAMATION
41 # include "nail.h"
42 #endif
44 #include <fcntl.h>
46 struct cmd {
47 char const *name; /* Name of command */
48 int (*func)(void*); /* Implementor of command */
49 enum argtype argtype; /* Arglist type (see below) */
50 short msgflag; /* Required flags of msgs */
51 short msgmask; /* Relevant flags of msgs */
52 #ifdef HAVE_DOCSTRINGS
53 char const *doc; /* One line doc for command */
54 #endif
56 /* Yechh, can't initialize unions */
57 #define minargs msgflag /* Minimum argcount for RAWLIST */
58 #define maxargs msgmask /* Max argcount for RAWLIST */
60 struct cmd_ghost {
61 struct cmd_ghost *next;
62 struct str cmd; /* Data follows after .name */
63 char name[VFIELD_SIZE(sizeof(size_t))];
66 static int *_msgvec;
67 static int _reset_on_stop; /* do a reset() if stopped */
68 static sighandler_type _oldpipe;
69 static struct cmd_ghost *_cmd_ghosts;
70 /* _cmd_tab[] after fun protos */
71 static int _lex_inithdr; /* am printing startup headers */
73 /* Update mailname (if name != NULL) and displayname, return wether displayname
74 * was large enough to swallow mailname */
75 static bool_t _update_mailname(char const *name);
76 #ifdef HAVE_C90AMEND1 /* TODO unite __narrow_suffix() into one fun! */
77 SINLINE size_t __narrow_suffix(char const *cp, size_t cpl, size_t maxl);
78 #endif
80 /* Isolate the command from the arguments */
81 static char * _lex_isolate(char const *comm);
83 /* Get first-fit, or NULL */
84 static struct cmd const * _lex(char const *comm);
86 /* Command ghost handling */
87 static int _ghost(void *v);
88 static int _unghost(void *v);
90 /* Print a list of all commands */
91 static int _pcmdlist(void *v);
92 static int __pcmd_cmp(void const *s1, void const *s2);
94 /* Print the binaries compiled-in features */
95 static int _features(void *v);
97 /* Print the binaries version number */
98 static int _version(void *v);
100 /* When we wake up after ^Z, reprint the prompt */
101 static void stop(int s);
103 /* Branch here on hangup signal and simulate "exit" */
104 static void hangup(int s);
106 /* List of all commands */
107 static struct cmd const _cmd_tab[] = {
108 #include "cmd_tab.h"
111 #ifdef HAVE_C90AMEND1
112 SINLINE size_t
113 __narrow_suffix(char const *cp, size_t cpl, size_t maxl)
115 int err;
116 size_t i, ok;
117 NYD_ENTER;
119 for (err = ok = i = 0; cpl > maxl || err;) {
120 int ml = mblen(cp, cpl);
121 if (ml < 0) { /* XXX _narrow_suffix(): mblen() error; action? */
122 (void)mblen(NULL, 0);
123 err = 1;
124 ml = 1;
125 } else {
126 if (!err)
127 ok = i;
128 err = 0;
129 if (ml == 0)
130 break;
132 cp += ml;
133 i += ml;
134 cpl -= ml;
136 NYD_LEAVE;
137 return ok;
139 #endif /* HAVE_C90AMEND1 */
141 static bool_t
142 _update_mailname(char const *name)
144 char tbuf[PATH_MAX], *mailp, *dispp;
145 size_t i, j;
146 bool_t rv = TRU1;
147 NYD_ENTER;
149 /* Don't realpath(3) if it's only an update request */
150 if (name != NULL) {
151 #ifdef HAVE_REALPATH
152 enum protocol p = which_protocol(name);
153 if (p == PROTO_FILE || p == PROTO_MAILDIR) {
154 if (realpath(name, mailname) == NULL) {
155 fprintf(stderr, _("Can't canonicalize `%s'\n"), name);
156 rv = FAL0;
157 goto jdocopy;
159 } else
160 jdocopy:
161 #endif
162 n_strlcpy(mailname, name, sizeof(mailname));
165 mailp = mailname;
166 dispp = displayname;
168 /* Don't display an absolute path but "+FOLDER" if under *folder* */
169 if (getfold(tbuf, sizeof tbuf)) {
170 i = strlen(tbuf);
171 if (i < sizeof(tbuf) -1)
172 tbuf[i++] = '/';
173 if (!strncmp(tbuf, mailp, i)) {
174 mailp += i;
175 *dispp++ = '+';
179 /* We want to see the name of the folder .. on the screen */
180 i = strlen(mailp);
181 if (i < sizeof(displayname) -1)
182 memcpy(dispp, mailp, i +1);
183 else {
184 rv = FAL0;
185 /* Avoid disrupting multibyte sequences (if possible) */
186 #ifndef HAVE_C90AMEND1
187 j = sizeof(displayname) / 3 - 1;
188 i -= sizeof(displayname) - (1/* + */ + 3) - j;
189 #else
190 j = field_detect_clip(sizeof(displayname) / 3, mailp, i);
191 i = j + __narrow_suffix(mailp + j, i - j,
192 sizeof(displayname) - (1/* + */ + 3 + 1) - j);
193 #endif
194 snprintf(dispp, sizeof(displayname), "%.*s...%s",
195 (int)j, mailp, mailp + i);
197 NYD_LEAVE;
198 return rv;
201 static char *
202 _lex_isolate(char const *comm)
204 NYD_ENTER;
205 while (*comm != '\0' &&
206 strchr("~|? \t0123456789&%@$^.:/-+*'\",;(`", *comm) == NULL)
207 ++comm;
208 NYD_LEAVE;
209 return UNCONST(comm);
212 static struct cmd const *
213 _lex(char const *comm) /* TODO **command hashtable**! linear list search!!! */
215 struct cmd const *cp;
216 NYD_ENTER;
218 for (cp = _cmd_tab; cp->name != NULL; ++cp)
219 if (*comm == *cp->name && is_prefix(comm, cp->name))
220 goto jleave;
221 cp = NULL;
222 jleave:
223 NYD_LEAVE;
224 return cp;
227 static int
228 _ghost(void *v)
230 char const **argv = v;
231 struct cmd_ghost *lcg, *cg;
232 size_t nl, cl;
233 NYD_ENTER;
235 /* Show the list? */
236 if (*argv == NULL) {
237 printf(_("Command ghosts are:\n"));
238 for (nl = 0, cg = _cmd_ghosts; cg != NULL; cg = cg->next) {
239 cl = strlen(cg->name) + 5 + cg->cmd.l + 3;
240 nl += cl;
241 if (UICMP(z, nl, >=, scrnwidth)) {
242 nl = cl;
243 printf("\n");
245 printf((cg->next != NULL ? "%s -> <%s>, " : "%s -> <%s>\n"),
246 cg->name, cg->cmd.s);
248 v = NULL;
249 goto jleave;
252 /* Request to add new ghost */
253 if (argv[1] == NULL || argv[1][0] == '\0' || argv[2] != NULL) {
254 fprintf(stderr, _("Usage: %s\n"),
255 _("Define a <ghost> of <command>, or list all ghosts"));
256 v = NULL;
257 goto jleave;
260 /* Check that we can deal with this one */
261 if (*argv[0] == '\0' || *_lex_isolate(argv[0]) != '\0') {
262 fprintf(stderr, _("Can't canonicalize `%s'\n"), argv[0]);
263 v = NULL;
264 goto jleave;
267 /* Always recreate */
268 for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
269 if (!strcmp(cg->name, argv[0])) {
270 if (lcg != NULL)
271 lcg->next = cg->next;
272 else
273 _cmd_ghosts = cg->next;
274 free(cg);
275 break;
278 /* Need a new one */
279 nl = strlen(argv[0]) +1;
280 cl = strlen(argv[1]) +1;
281 cg = smalloc(sizeof(*cg) - VFIELD_SIZEOF(struct cmd_ghost, name) + nl + cl);
282 cg->next = _cmd_ghosts;
283 memcpy(cg->name, argv[0], nl);
284 cg->cmd.s = cg->name + nl;
285 cg->cmd.l = cl -1;
286 memcpy(cg->cmd.s, argv[1], cl);
288 _cmd_ghosts = cg;
289 jleave:
290 NYD_LEAVE;
291 return (v == NULL);
294 static int
295 _unghost(void *v)
297 int rv = 0;
298 char const **argv = v, *cp;
299 struct cmd_ghost *lcg, *cg;
300 NYD_ENTER;
302 while ((cp = *argv++) != NULL) {
303 for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
304 if (!strcmp(cg->name, cp)) {
305 if (lcg != NULL)
306 lcg->next = cg->next;
307 else
308 _cmd_ghosts = cg->next;
309 free(cg);
310 goto jouter;
312 fprintf(stderr, _("Unknown command: `%s'\n"), cp);
313 rv = 1;
314 jouter:
317 NYD_LEAVE;
318 return rv;
321 static int
322 __pcmd_cmp(void const *s1, void const *s2)
324 struct cmd const * const *c1 = s1, * const *c2 = s2;
325 int rv;
326 NYD_ENTER;
328 rv = strcmp((*c1)->name, (*c2)->name);
329 NYD_LEAVE;
330 return rv;
333 static int
334 _pcmdlist(void *v)
336 struct cmd const **cpa, *cp, **cursor;
337 size_t i;
338 NYD_ENTER;
339 UNUSED(v);
341 for (i = 0; _cmd_tab[i].name != NULL; ++i)
343 ++i;
344 cpa = ac_alloc(sizeof(cp) * i);
346 for (i = 0; (cp = _cmd_tab + i)->name != NULL; ++i)
347 cpa[i] = cp;
348 cpa[i] = NULL;
350 qsort(cpa, i, sizeof(cp), &__pcmd_cmp);
352 printf(_("Commands are:\n"));
353 for (i = 0, cursor = cpa; (cp = *cursor++) != NULL;) {
354 size_t j;
355 if (cp->func == &c_cmdnotsupp)
356 continue;
357 j = strlen(cp->name) + 2;
358 if ((i += j) > 72) {
359 i = j;
360 printf("\n");
362 printf((*cursor != NULL ? "%s, " : "%s\n"), cp->name);
365 ac_free(cpa);
366 NYD_LEAVE;
367 return 0;
370 static int
371 _features(void *v)
373 NYD_ENTER;
374 UNUSED(v);
375 printf(_("Features: %s\n"), features);
376 NYD_LEAVE;
377 return 0;
380 static int
381 _version(void *v)
383 NYD_ENTER;
384 UNUSED(v);
385 printf(_("Version %s\n"), version);
386 NYD_LEAVE;
387 return 0;
390 static void
391 stop(int s)
393 sighandler_type old_action;
394 sigset_t nset;
395 NYD_X; /* Signal handler */
397 old_action = safe_signal(s, SIG_DFL);
399 sigemptyset(&nset);
400 sigaddset(&nset, s);
401 sigprocmask(SIG_UNBLOCK, &nset, NULL);
402 kill(0, s);
403 sigprocmask(SIG_BLOCK, &nset, NULL);
404 safe_signal(s, old_action);
405 if (_reset_on_stop) {
406 _reset_on_stop = 0;
407 reset(0);
411 static void
412 hangup(int s)
414 NYD_X; /* Signal handler */
415 UNUSED(s);
416 /* nothing to do? */
417 exit(1);
420 FL int
421 setfile(char const *name, enum fedit_mode fm) /* TODO oh my god */
423 static int shudclob;
425 struct stat stb;
426 struct flock flp;
427 FILE *ibuf = NULL;
428 int rv, i, compressed = 0, omsgCount = 0;
429 char const *who;
430 size_t offset;
431 struct shortcut *sh;
432 NYD_ENTER;
434 /* Note we don't 'userid(myname) != getuid()', preliminary steps are usually
435 * necessary to make a mailbox accessible by a different user, and if that
436 * has happened, let's just let the usual file perms decide */
437 who = (name[1] != '\0') ? name + 1 : myname;
439 #if 1
440 if (name[0] == '%' ||
441 ((sh = get_shortcut(name)) != NULL && *sh->sh_long == '%'))
442 fm |= FEDIT_SYSBOX; /* TODO fexpand() needs to tell is-valid-user! */
443 #else
444 if (name[0] == '%' && (name[1] == '\0' || name[1] == ':'))
445 fm |= FEDIT_SYSBOX;
446 else if ((sh = get_shortcut(name)) != NULL) {
447 char const *x = sh->sh_long;
449 if (x[0] == '%' && (x[1] == '\0' || x[1] == ':'))
450 fm |= FEDIT_SYSBOX;
452 #endif
453 if ((name = expand(name)) == NULL)
454 goto jem1;
456 switch (which_protocol(name)) {
457 case PROTO_FILE:
458 break;
459 case PROTO_MAILDIR:
460 rv = maildir_setfile(name, fm);
461 goto jleave;
462 #ifdef HAVE_POP3
463 case PROTO_POP3:
464 shudclob = 1;
465 rv = pop3_setfile(name, fm);
466 goto jleave;
467 #endif
468 #ifdef HAVE_IMAP
469 case PROTO_IMAP:
470 shudclob = 1;
471 if ((fm & FEDIT_NEWMAIL) && mb.mb_type == MB_CACHE)
472 rv = 1;
473 else
474 rv = imap_setfile(name, fm);
475 goto jleave;
476 #endif
477 default:
478 fprintf(stderr, _("Cannot handle protocol: %s\n"), name);
479 goto jem1;
482 /* FIXME this FILE leaks if quit()->edstop() reset()s! This entire code
483 * FIXME here is total crap, below we open(2) the same name again just to
484 * FIXME close it right away etc. The normal thing would be to (1) finalize
485 * FIXME the current box and (2) open the new box; yet, since (2) may fail
486 * FIXME we terribly need our VOID box to make this logic order possible! */
487 if ((ibuf = Zopen(name, "r", &compressed)) == NULL) {
488 if (((fm & FEDIT_SYSBOX) && errno == ENOENT) || (fm & FEDIT_NEWMAIL)) {
489 if (fm & FEDIT_NEWMAIL)
490 goto jnonmail;
491 goto jnomail;
493 perror(name);
494 goto jem1;
497 if (fstat(fileno(ibuf), &stb) == -1) {
498 if (fm & FEDIT_NEWMAIL)
499 goto jnonmail;
500 perror("fstat");
501 goto jem1;
504 if (S_ISREG(stb.st_mode) ||
505 ((options & OPT_BATCH_FLAG) && !strcmp(name, "/dev/null"))) {
506 /* EMPTY */
507 } else {
508 if (fm & FEDIT_NEWMAIL)
509 goto jnonmail;
510 errno = S_ISDIR(stb.st_mode) ? EISDIR : EINVAL;
511 perror(name);
512 goto jem1;
515 /* Looks like all will be well. We must now relinquish our hold on the
516 * current set of stuff. Must hold signals while we are reading the new
517 * file, else we will ruin the message[] data structure */
519 hold_sigs(); /* TODO note on this one in quit.c:quit() */
520 if (shudclob && !(fm & FEDIT_NEWMAIL))
521 quit();
522 #ifdef HAVE_SOCKETS
523 if (!(fm & FEDIT_NEWMAIL) && mb.mb_sock.s_fd >= 0)
524 sclose(&mb.mb_sock); /* TODO sorry? VMAILFS->close(), thank you */
525 #endif
527 /* Copy the messages into /tmp and set pointers */
528 flp.l_type = F_RDLCK;
529 flp.l_start = 0;
530 flp.l_whence = SEEK_SET;
531 if (!(fm & FEDIT_NEWMAIL)) {
532 mb.mb_type = MB_FILE;
533 mb.mb_perm = (((options & OPT_R_FLAG) || (fm & FEDIT_RDONLY))
534 ? 0 : MB_DELE | MB_EDIT);
535 mb.mb_compressed = compressed;
536 if (compressed) {
537 if (compressed & 0200)
538 mb.mb_perm = 0;
539 } else {
540 if ((i = open(name, O_WRONLY)) == -1)
541 mb.mb_perm = 0;
542 else
543 close(i);
545 if (shudclob) {
546 if (mb.mb_itf) {
547 fclose(mb.mb_itf);
548 mb.mb_itf = NULL;
550 if (mb.mb_otf) {
551 fclose(mb.mb_otf);
552 mb.mb_otf = NULL;
555 shudclob = 1;
556 edit = !(fm & FEDIT_SYSBOX);
557 initbox(name);
558 offset = 0;
559 flp.l_len = 0;
560 if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) == -1) {/*TODO dotlock!*/
561 perror("Unable to lock mailbox");
562 rele_sigs();
563 goto jem1;
565 } else /* FEDIT_NEWMAIL */{
566 fseek(mb.mb_otf, 0L, SEEK_END);
567 fseek(ibuf, mailsize, SEEK_SET);
568 offset = mailsize;
569 omsgCount = msgCount;
570 flp.l_len = offset;
571 if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) == -1) {/*TODO dotlock!*/
572 rele_sigs();
573 goto jnonmail;
576 mailsize = fsize(ibuf);
578 if ((fm & FEDIT_NEWMAIL) && UICMP(z, mailsize, <=, offset)) {
579 rele_sigs();
580 goto jnonmail;
582 setptr(ibuf, offset);
583 setmsize(msgCount);
584 if ((fm & FEDIT_NEWMAIL) && mb.mb_sorted) {
585 mb.mb_threaded = 0;
586 c_sort((void*)-1);
589 Fclose(ibuf);
590 ibuf = NULL;
591 rele_sigs();
592 if (!(fm & FEDIT_NEWMAIL))
593 sawcom = FAL0;
595 if ((!edit || (fm & FEDIT_NEWMAIL)) && msgCount == 0) {
596 jnonmail:
597 if (!(fm & FEDIT_NEWMAIL)) {
598 if (!ok_blook(emptystart))
599 jnomail:
600 fprintf(stderr, _("No mail for %s\n"), who);
602 rv = 1;
603 goto jleave;
605 if (fm & FEDIT_NEWMAIL)
606 newmailinfo(omsgCount);
608 rv = 0;
609 jleave:
610 if (ibuf != NULL)
611 Fclose(ibuf);
612 NYD_LEAVE;
613 return rv;
614 jem1:
615 rv = -1;
616 goto jleave;
619 FL int
620 newmailinfo(int omsgCount)
622 int mdot, i;
623 NYD_ENTER;
625 for (i = 0; i < omsgCount; ++i)
626 message[i].m_flag &= ~MNEWEST;
627 if (msgCount > omsgCount) {
628 for (i = omsgCount; i < msgCount; ++i)
629 message[i].m_flag |= MNEWEST;
630 printf(_("New mail has arrived.\n"));
631 if ((i = msgCount - omsgCount) == 1)
632 printf(_("Loaded 1 new message.\n"));
633 else
634 printf(_("Loaded %d new messages.\n"), i);
635 } else
636 printf(_("Loaded %d messages.\n"), msgCount);
637 callhook(mailname, 1);
638 mdot = getmdot(1);
639 if (ok_blook(header))
640 print_headers(omsgCount + 1, msgCount, FAL0);
641 NYD_LEAVE;
642 return mdot;
645 FL bool_t
646 commands(void)
648 struct eval_ctx ev;
649 int n;
650 bool_t volatile rv = TRU1;
651 NYD_ENTER;
653 if (!sourcing) {
654 if (safe_signal(SIGINT, SIG_IGN) != SIG_IGN)
655 safe_signal(SIGINT, onintr);
656 if (safe_signal(SIGHUP, SIG_IGN) != SIG_IGN)
657 safe_signal(SIGHUP, hangup);
658 /* TODO We do a lot of redundant signal handling, especially
659 * TODO with the command line editor(s); try to merge this */
660 safe_signal(SIGTSTP, stop);
661 safe_signal(SIGTTOU, stop);
662 safe_signal(SIGTTIN, stop);
664 _oldpipe = safe_signal(SIGPIPE, SIG_IGN);
665 safe_signal(SIGPIPE, _oldpipe);
667 memset(&ev, 0, sizeof ev);
669 setexit();
670 for (;;) {
671 interrupts = 0;
672 handlerstacktop = NULL;
674 if (!sourcing && (options & OPT_INTERACTIVE)) {
675 char *cp;
677 cp = ok_vlook(newmail);
678 if ((options & OPT_TTYIN) && (cp != NULL || mb.mb_type == MB_IMAP)) {
679 struct stat st;
681 n = (cp != NULL && strcmp(cp, "noimap") && strcmp(cp, "nopoll"));
682 if ((mb.mb_type == MB_FILE && !stat(mailname, &st) &&
683 st.st_size > mailsize) ||
684 #ifdef HAVE_IMAP
685 (mb.mb_type == MB_IMAP && imap_newmail(n) > (cp == NULL)) ||
686 #endif
687 (mb.mb_type == MB_MAILDIR && n != 0)) {
688 size_t odot = PTR2SIZE(dot - message);
689 bool_t odid = did_print_dot;
691 setfile(mailname, 1);
692 if (mb.mb_type != MB_IMAP) {
693 dot = message + odot;
694 did_print_dot = odid;
699 _reset_on_stop = 1;
700 exit_status = EXIT_OK;
703 #ifdef HAVE_COLOUR
704 colour_table = NULL; /* XXX intermediate hack */
705 #endif
706 if (temporary_localopts_store != NULL) /* XXX intermediate hack */
707 temporary_localopts_free(); /* XXX intermediate hack */
708 sreset(sourcing);
709 if (!sourcing) {
710 char *cp;
712 /* TODO Note: this buffer may contain a password. We should redefine
713 * TODO the code flow which has to do that */
714 if ((cp = termios_state.ts_linebuf) != NULL) {
715 termios_state.ts_linebuf = NULL;
716 termios_state.ts_linesize = 0;
717 free(cp); /* TODO pool give-back */
719 /* TODO Due to expand-on-tab of NCL the buffer may grow */
720 if (ev.ev_line.l > LINESIZE * 3) {
721 free(ev.ev_line.s); /* TODO pool! but what? */
722 ev.ev_line.s = NULL;
723 ev.ev_line.l = 0;
727 /* Read a line of commands and handle end of file specially */
728 jreadline:
729 ev.ev_line.l = ev.ev_line_size;
730 n = readline_input(NULL, TRU1, &ev.ev_line.s, &ev.ev_line.l,
731 ev.ev_new_content);
732 ev.ev_line_size = (ui32_t)ev.ev_line.l;
733 ev.ev_line.l = (ui32_t)n;
734 _reset_on_stop = 0;
735 if (n < 0) {
736 /* EOF */
737 if (loading)
738 break;
739 if (sourcing) {
740 unstack();
741 continue;
743 if ((options & OPT_INTERACTIVE) && ok_blook(ignoreeof)) {
744 printf(_("Use `quit' to quit.\n"));
745 continue;
747 break;
750 inhook = 0;
751 if (evaluate(&ev)) {
752 if (loading) /* TODO mess; join with exec_last_comm_error etc.. */
753 rv = FAL0;
754 break;
756 if ((options & OPT_BATCH_FLAG) && ok_blook(batch_exit_on_error)) {
757 if (exit_status != EXIT_OK)
758 break;
759 /* TODO *batch-exit-on-error*: sourcing and loading MUST BE FLAGS!
760 * TODO the current behaviour is suboptimal AT BEST! */
761 if (exec_last_comm_error != 0 && !sourcing && !loading) {
762 exit_status = EXIT_ERR;
763 break;
766 if (!sourcing && (options & OPT_INTERACTIVE)) {
767 if (ev.ev_new_content != NULL)
768 goto jreadline;
769 tty_addhist(ev.ev_line.s, !ev.ev_add_history);
773 if (ev.ev_line.s != NULL)
774 free(ev.ev_line.s);
775 if (sourcing)
776 sreset(FAL0);
777 NYD_LEAVE;
778 return rv;
781 FL int
782 execute(char *linebuf, int contxt, size_t linesize) /* XXX LEGACY */
784 struct eval_ctx ev;
785 #ifdef HAVE_COLOUR
786 struct colour_table *ct_save;
787 #endif
788 int rv;
789 NYD_ENTER;
791 /* TODO Maybe recursion from within collect.c! As long as we don't have
792 * TODO a value carrier that transports the entire state of a recursion
793 * TODO we need to save away also the colour table */
794 #ifdef HAVE_COLOUR
795 ct_save = colour_table;
796 colour_table = NULL;
797 #endif
799 memset(&ev, 0, sizeof ev);
800 ev.ev_line.s = linebuf;
801 ev.ev_line.l = linesize;
802 ev.ev_is_recursive = (contxt != 0);
803 rv = evaluate(&ev);
805 if (contxt)
806 tty_addhist(ev.ev_line.s, TRU1);
808 #ifdef HAVE_COLOUR
809 colour_table = ct_save;
810 #endif
811 NYD_LEAVE;
812 return rv;
815 FL int
816 evaluate(struct eval_ctx *evp)
818 struct str line;
819 char _wordbuf[2], *arglist[MAXARGC], *cp, *word;
820 struct cmd_ghost *cg = NULL;
821 struct cmd const *com = NULL;
822 int muvec[2], c, e = 1;
823 NYD_ENTER;
825 line = evp->ev_line; /* XXX don't change original (buffer pointer) */
826 evp->ev_add_history = FAL0;
827 evp->ev_new_content = NULL;
829 /* Command ghosts that refer to shell commands or macro expansion restart */
830 jrestart:
832 /* Strip the white space away from the beginning of the command */
833 for (cp = line.s; whitechar(*cp); ++cp)
835 line.l -= PTR2SIZE(cp - line.s);
837 /* Ignore comments */
838 if (*cp == '#')
839 goto jleave0;
841 /* Handle ! differently to get the correct lexical conventions */
842 if (*cp == '!') {
843 if (sourcing) {
844 fprintf(stderr, _("Can't `!' while sourcing\n"));
845 goto jleave;
847 c_shell(++cp);
848 evp->ev_add_history = TRU1;
849 goto jleave0;
852 /* Isolate the actual command; since it may not necessarily be
853 * separated from the arguments (as in `p1') we need to duplicate it to
854 * be able to create a NUL terminated version.
855 * We must be aware of several special one letter commands here */
856 arglist[0] = cp;
857 if ((cp = _lex_isolate(cp)) == arglist[0] &&
858 (*cp == '|' || *cp == '~' || *cp == '?'))
859 ++cp;
860 c = (int)PTR2SIZE(cp - arglist[0]);
861 line.l -= c;
862 word = UICMP(z, c, <, sizeof _wordbuf) ? _wordbuf : salloc(c +1);
863 memcpy(word, arglist[0], c);
864 word[c] = '\0';
866 /* Look up the command; if not found, bitch.
867 * Normally, a blank command would map to the first command in the
868 * table; while sourcing, however, we ignore blank lines to eliminate
869 * confusion; act just the same for ghosts */
870 if (*word == '\0') {
871 if (sourcing || cg != NULL)
872 goto jleave0;
873 com = _cmd_tab + 0;
874 goto jexec;
877 /* If this is the first evaluation, check command ghosts */
878 if (cg == NULL) {
879 /* TODO relink list head, so it's sorted on usage over time?
880 * TODO in fact, there should be one hashmap over all commands and ghosts
881 * TODO so that the lookup could be made much more efficient than it is
882 * TODO now (two adjacent list searches! */
883 for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
884 if (!strcmp(word, cg->name)) {
885 if (line.l > 0) {
886 size_t i = cg->cmd.l;
887 line.s = salloc(i + 1 + line.l +1);
888 memcpy(line.s, cg->cmd.s, i);
889 line.s[i++] = ' ';
890 memcpy(line.s + i, cp, line.l);
891 line.s[i += line.l] = '\0';
892 line.l = i;
893 } else {
894 line.s = cg->cmd.s;
895 line.l = cg->cmd.l;
897 goto jrestart;
901 if ((com = _lex(word)) == NULL || com->func == &c_cmdnotsupp) {
902 fprintf(stderr, _("Unknown command: `%s'\n"), word);
903 if (com != NULL) {
904 c_cmdnotsupp(NULL);
905 com = NULL;
907 goto jleave;
910 /* See if we should execute the command -- if a conditional we always
911 * execute it, otherwise, check the state of cond */
912 jexec:
913 if (!(com->argtype & ARG_F) && condstack_isskip())
914 goto jleave0;
916 /* Process the arguments to the command, depending on the type it expects,
917 * default to error. If we're sourcing an interactive command: error */
918 if ((options & OPT_SENDMODE) && !(com->argtype & ARG_M)) {
919 fprintf(stderr, _("May not execute `%s' while sending\n"),
920 com->name);
921 goto jleave;
923 if (sourcing && (com->argtype & ARG_I)) {
924 fprintf(stderr, _("May not execute `%s' while sourcing\n"),
925 com->name);
926 goto jleave;
928 if (!(mb.mb_perm & MB_DELE) && (com->argtype & ARG_W)) {
929 fprintf(stderr, _("May not execute `%s' -- "
930 "message file is read only\n"), com->name);
931 goto jleave;
933 if (evp->ev_is_recursive && (com->argtype & ARG_R)) {
934 fprintf(stderr, _("Cannot recursively invoke `%s'\n"), com->name);
935 goto jleave;
937 if (mb.mb_type == MB_VOID && (com->argtype & ARG_A)) {
938 fprintf(stderr, _("Cannot execute `%s' without active mailbox\n"),
939 com->name);
940 goto jleave;
943 if (com->argtype & ARG_V)
944 temporary_arg_v_store = NULL;
946 switch (com->argtype & ARG_ARGMASK) {
947 case ARG_MSGLIST:
948 /* Message list defaulting to nearest forward legal message */
949 if (_msgvec == NULL)
950 goto je96;
951 if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
952 break;
953 if (c == 0) {
954 *_msgvec = first(com->msgflag, com->msgmask);
955 if (*_msgvec != 0)
956 _msgvec[1] = 0;
958 if (*_msgvec == 0) {
959 if (!inhook)
960 printf(_("No applicable messages\n"));
961 break;
963 e = (*com->func)(_msgvec);
964 break;
966 case ARG_NDMLIST:
967 /* Message list with no defaults, but no error if none exist */
968 if (_msgvec == NULL) {
969 je96:
970 fprintf(stderr, _("Invalid use of `message list'\n"));
971 break;
973 if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
974 break;
975 e = (*com->func)(_msgvec);
976 break;
978 case ARG_STRLIST:
979 /* Just the straight string, with leading blanks removed */
980 while (whitechar(*cp))
981 ++cp;
982 e = (*com->func)(cp);
983 break;
985 case ARG_RAWLIST:
986 case ARG_ECHOLIST:
987 /* A vector of strings, in shell style */
988 if ((c = getrawlist(cp, line.l, arglist, NELEM(arglist),
989 ((com->argtype & ARG_ARGMASK) == ARG_ECHOLIST))) < 0)
990 break;
991 if (c < com->minargs) {
992 fprintf(stderr, _("`%s' requires at least %d arg(s)\n"),
993 com->name, com->minargs);
994 break;
996 if (c > com->maxargs) {
997 fprintf(stderr, _("`%s' takes no more than %d arg(s)\n"),
998 com->name, com->maxargs);
999 break;
1001 e = (*com->func)(arglist);
1002 break;
1004 case ARG_NOLIST:
1005 /* Just the constant zero, for exiting, eg. */
1006 e = (*com->func)(0);
1007 break;
1009 default:
1010 panic(_("Unknown argument type"));
1013 if (e == 0 && (com->argtype & ARG_V) &&
1014 (cp = temporary_arg_v_store) != NULL) {
1015 temporary_arg_v_store = NULL;
1016 evp->ev_new_content = cp;
1017 goto jleave0;
1019 if (!(com->argtype & ARG_H) && !list_saw_numbers)
1020 evp->ev_add_history = TRU1;
1022 jleave:
1023 /* Exit the current source file on error TODO what a mess! */
1024 if ((exec_last_comm_error = (e != 0))) {
1025 if (e < 0 || loading) {
1026 e = 1;
1027 goto jret;
1029 if (sourcing)
1030 unstack();
1031 goto jret0;
1033 if (com == NULL)
1034 goto jret0;
1035 if ((com->argtype & ARG_P) && ok_blook(autoprint))
1036 if (visible(dot)) {
1037 muvec[0] = (int)PTR2SIZE(dot - message + 1);
1038 muvec[1] = 0;
1039 c_type(muvec); /* TODO what if error? re-eval! */
1041 if (!sourcing && !inhook && !(com->argtype & ARG_T))
1042 sawcom = TRU1;
1043 jleave0:
1044 exec_last_comm_error = 0;
1045 jret0:
1046 e = 0;
1047 jret:
1048 NYD_LEAVE;
1049 return e;
1052 FL void
1053 setmsize(int sz)
1055 NYD_ENTER;
1056 if (_msgvec != NULL)
1057 free(_msgvec);
1058 _msgvec = scalloc(sz + 1, sizeof *_msgvec);
1059 NYD_LEAVE;
1062 FL void
1063 print_header_summary(char const *Larg)
1065 size_t bot, top, i, j;
1066 NYD_ENTER;
1068 if (Larg != NULL) {
1069 /* Avoid any messages XXX add a make_mua_silent() and use it? */
1070 if ((options & (OPT_VERB | OPT_HEADERSONLY)) == OPT_HEADERSONLY) {
1071 freopen("/dev/null", "w", stdout);
1072 freopen("/dev/null", "w", stderr);
1074 assert(_msgvec != NULL);
1075 i = (getmsglist(/*TODO make arg const */UNCONST(Larg), _msgvec, 0) <= 0);
1076 if (options & OPT_HEADERSONLY) {
1077 exit_status = (int)i;
1078 goto jleave;
1080 if (i)
1081 goto jleave;
1082 for (bot = msgCount, top = 0, i = 0; (j = _msgvec[i]) != 0; ++i) {
1083 if (bot > j)
1084 bot = j;
1085 if (top < j)
1086 top = j;
1088 } else
1089 bot = 1, top = msgCount;
1090 print_headers(bot, top, (Larg != NULL)); /* TODO should take iterator!! */
1091 jleave:
1092 NYD_LEAVE;
1095 FL void
1096 onintr(int s)
1098 NYD_X; /* Signal handler */
1100 if (handlerstacktop != NULL) {
1101 handlerstacktop(s);
1102 return;
1104 safe_signal(SIGINT, onintr);
1105 noreset = 0;
1106 if (!_lex_inithdr)
1107 sawcom = TRU1;
1108 _lex_inithdr = 0;
1109 while (sourcing)
1110 unstack();
1112 termios_state_reset();
1113 close_all_files();
1115 if (image >= 0) {
1116 close(image);
1117 image = -1;
1119 if (interrupts != 1)
1120 fprintf(stderr, _("Interrupt\n"));
1121 safe_signal(SIGPIPE, _oldpipe);
1122 reset(0);
1125 FL void
1126 announce(int printheaders)
1128 int vec[2], mdot;
1129 NYD_ENTER;
1131 mdot = newfileinfo();
1132 vec[0] = mdot;
1133 vec[1] = 0;
1134 dot = message + mdot - 1;
1135 if (printheaders && msgCount > 0 && ok_blook(header)) {
1136 ++_lex_inithdr;
1137 c_headers(vec); /* XXX errors? */
1138 _lex_inithdr = 0;
1140 NYD_LEAVE;
1143 FL int
1144 newfileinfo(void)
1146 struct message *mp;
1147 int u, n, mdot, d, s, hidden, moved;
1148 NYD_ENTER;
1150 if (mb.mb_type == MB_VOID) {
1151 mdot = 1;
1152 goto jleave;
1155 mdot = getmdot(0);
1156 s = d = hidden = moved =0;
1157 for (mp = message, n = 0, u = 0; PTRCMP(mp, <, message + msgCount); ++mp) {
1158 if (mp->m_flag & MNEW)
1159 ++n;
1160 if ((mp->m_flag & MREAD) == 0)
1161 ++u;
1162 if ((mp->m_flag & (MDELETED | MSAVED)) == (MDELETED | MSAVED))
1163 ++moved;
1164 if ((mp->m_flag & (MDELETED | MSAVED)) == MDELETED)
1165 ++d;
1166 if ((mp->m_flag & (MDELETED | MSAVED)) == MSAVED)
1167 ++s;
1168 if (mp->m_flag & MHIDDEN)
1169 ++hidden;
1172 /* If displayname gets truncated the user effectively has no option to see
1173 * the full pathname of the mailbox, so print it at least for '? fi' */
1174 printf(_("\"%s\": "),
1175 (_update_mailname(NULL) ? displayname : mailname));
1176 if (msgCount == 1)
1177 printf(_("1 message"));
1178 else
1179 printf(_("%d messages"), msgCount);
1180 if (n > 0)
1181 printf(_(" %d new"), n);
1182 if (u-n > 0)
1183 printf(_(" %d unread"), u);
1184 if (d > 0)
1185 printf(_(" %d deleted"), d);
1186 if (s > 0)
1187 printf(_(" %d saved"), s);
1188 if (moved > 0)
1189 printf(_(" %d moved"), moved);
1190 if (hidden > 0)
1191 printf(_(" %d hidden"), hidden);
1192 if (mb.mb_type == MB_CACHE)
1193 printf(" [Disconnected]");
1194 else if (mb.mb_perm == 0)
1195 printf(_(" [Read only]"));
1196 printf("\n");
1197 jleave:
1198 NYD_LEAVE;
1199 return mdot;
1202 FL int
1203 getmdot(int nmail)
1205 struct message *mp;
1206 char *cp;
1207 int mdot;
1208 enum mflag avoid = MHIDDEN | MDELETED;
1209 NYD_ENTER;
1211 if (!nmail) {
1212 if (ok_blook(autothread))
1213 c_thread(NULL);
1214 else if ((cp = ok_vlook(autosort)) != NULL) {
1215 free(mb.mb_sorted);
1216 mb.mb_sorted = sstrdup(cp);
1217 c_sort(NULL);
1220 if (mb.mb_type == MB_VOID) {
1221 mdot = 1;
1222 goto jleave;
1225 if (nmail)
1226 for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1227 if ((mp->m_flag & (MNEWEST | avoid)) == MNEWEST)
1228 break;
1230 if (!nmail || PTRCMP(mp, >=, message + msgCount)) {
1231 if (mb.mb_threaded) {
1232 for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1233 if ((mp->m_flag & (MNEW | avoid)) == MNEW)
1234 break;
1235 } else {
1236 for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1237 if ((mp->m_flag & (MNEW | avoid)) == MNEW)
1238 break;
1242 if ((mb.mb_threaded ? (mp == NULL) : PTRCMP(mp, >=, message + msgCount))) {
1243 if (mb.mb_threaded) {
1244 for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1245 if (mp->m_flag & MFLAGGED)
1246 break;
1247 } else {
1248 for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1249 if (mp->m_flag & MFLAGGED)
1250 break;
1254 if ((mb.mb_threaded ? (mp == NULL) : PTRCMP(mp, >=, message + msgCount))) {
1255 if (mb.mb_threaded) {
1256 for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1257 if (!(mp->m_flag & (MREAD | avoid)))
1258 break;
1259 } else {
1260 for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1261 if (!(mp->m_flag & (MREAD | avoid)))
1262 break;
1266 if ((mb.mb_threaded ? (mp != NULL) : PTRCMP(mp, <, message + msgCount)))
1267 mdot = (int)PTR2SIZE(mp - message + 1);
1268 else if (ok_blook(showlast)) {
1269 if (mb.mb_threaded) {
1270 for (mp = this_in_thread(threadroot, -1); mp;
1271 mp = prev_in_thread(mp))
1272 if (!(mp->m_flag & avoid))
1273 break;
1274 mdot = (mp != NULL) ? (int)PTR2SIZE(mp - message + 1) : msgCount;
1275 } else {
1276 for (mp = message + msgCount - 1; mp >= message; --mp)
1277 if (!(mp->m_flag & avoid))
1278 break;
1279 mdot = (mp >= message) ? (int)PTR2SIZE(mp - message + 1) : msgCount;
1281 } else if (mb.mb_threaded) {
1282 for (mp = threadroot; mp; mp = next_in_thread(mp))
1283 if (!(mp->m_flag & avoid))
1284 break;
1285 mdot = (mp != NULL) ? (int)PTR2SIZE(mp - message + 1) : 1;
1286 } else {
1287 for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1288 if (!(mp->m_flag & avoid))
1289 break;
1290 mdot = PTRCMP(mp, <, message + msgCount)
1291 ? (int)PTR2SIZE(mp - message + 1) : 1;
1293 jleave:
1294 NYD_LEAVE;
1295 return mdot;
1298 FL void
1299 initbox(char const *name)
1301 char *tempMesg;
1302 NYD_ENTER;
1304 if (mb.mb_type != MB_VOID)
1305 n_strlcpy(prevfile, mailname, PATH_MAX);
1307 _update_mailname((name != mailname) ? name : NULL);
1309 if ((mb.mb_otf = Ftmp(&tempMesg, "tmpbox", OF_WRONLY | OF_HOLDSIGS, 0600)) ==
1310 NULL) {
1311 perror(_("temporary mail message file"));
1312 exit(1);
1314 if ((mb.mb_itf = safe_fopen(tempMesg, "r", NULL)) == NULL) {
1315 perror(_("temporary mail message file"));
1316 exit(1);
1318 Ftmp_release(&tempMesg);
1320 message_reset();
1321 mb.mb_threaded = 0;
1322 if (mb.mb_sorted != NULL) {
1323 free(mb.mb_sorted);
1324 mb.mb_sorted = NULL;
1326 #ifdef HAVE_IMAP
1327 mb.mb_flags = MB_NOFLAGS;
1328 #endif
1329 prevdot = NULL;
1330 dot = NULL;
1331 did_print_dot = FAL0;
1332 NYD_LEAVE;
1335 #ifdef HAVE_DOCSTRINGS
1336 FL bool_t
1337 print_comm_docstr(char const *comm)
1339 bool_t rv = FAL0;
1340 struct cmd_ghost *cg;
1341 struct cmd const *cp;
1342 NYD_ENTER;
1344 /* Ghosts take precedence */
1345 for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
1346 if (!strcmp(comm, cg->name)) {
1347 printf("%s -> <%s>\n", comm, cg->cmd.s);
1348 rv = TRU1;
1349 goto jleave;
1352 for (cp = _cmd_tab; cp->name != NULL; ++cp) {
1353 if (cp->func == &c_cmdnotsupp)
1354 continue;
1355 if (!strcmp(comm, cp->name))
1356 printf("%s: %s\n", comm, V_(cp->doc));
1357 else if (is_prefix(comm, cp->name))
1358 printf("%s (%s): %s\n", comm, cp->name, V_(cp->doc));
1359 else
1360 continue;
1361 rv = TRU1;
1362 break;
1364 jleave:
1365 NYD_LEAVE;
1366 return rv;
1368 #endif
1370 /* s-it-mode */