commands.c

Go to the documentation of this file.

/* Copyright (c) 1985 Ceriel J.H. Jacobs */

# ifndef lint
static char rcsid[] = "$Header: /opt/proj/minix/cvsroot/src/commands/yap/commands.c,v 1.1.1.1 2005/04/21 14:55:38 beng Exp $";
# endif

# define _COMMANDS_

# include "in_all.h"
# include "commands.h"
# include "output.h"
# include "process.h"
# include "help.h"
# include "term.h"
# include "prompt.h"
# include "getline.h"
# include "getcomm.h"
# include "pattern.h"
# include "display.h"
# include "options.h"
# include "machine.h"
# include "keys.h"
# include "main.h"
# include "assert.h"
# if USG_OPEN
# include <fcntl.h>
# include <errno.h>
extern int errno;
# endif
# if BSD4_2_OPEN
# include <sys/file.h>
# include <errno.h>
extern int errno;
# endif
# if POSIX_OPEN
# include <sys/types.h>
# include <fcntl.h>
# include <errno.h>
# endif

char    *strcpy(), *strcat();

static long lastcount;          /* Save last count for '.' command */
static int lastcomm;            /* Save last command for '.' command */

/*ARGSUSED*/
STATIC int
do_nocomm(cnt) long cnt; {      /* Do nothing */
}

/*ARGSUSED*/
int
do_chkm(cnt) long cnt; {        /* Change key map */
        register struct keymap *p;

        if (!(p = othermap)) {
                error("No other keymap");
                return;
        }
        othermap = currmap;
        currmap = p;
}

static int searchdir;           /* Direction of last search */

/*
 * Perform searches
 */

STATIC VOID
do_search(str,cnt,dir) char *str; long cnt; int dir; {
        register char *p;
        register long lineno;

        if (str) {
                /*
                 * We have to get a pattern, which we have to prompt for
                 * with the string "str".
                 */
                if ((p = readline(str)) == 0) {
                        /*
                         * User cancelled command
                         */
                        return;
                }
                if ((p = re_comp(p))) {
                        /*
                         * There was an error in the pattern
                         */
                        error(p);
                        return;
                }
                searchdir = dir;
        }
        if (dir < 0) lineno = scr_info.firstline;
        else lineno = scr_info.lastline;
        for (;;) {
                p = 0;
                if ((lineno += dir) > 0) p = getline(lineno, 0);
                if (interrupt) return;
                if (!p) {       /* End of file reached */
                        error("pattern not found");
                        return;
                }
                if (re_exec(p) && --cnt <= 0) {
                        /*
                         * We found the pattern, and we found it often enough.
                         * Pity that we still don't know where the match is.
                         * We only know the linenumber. So, we just hope the
                         * following will at least bring it on the screen ...
                         */
                        (VOID) display(lineno,0,pagesize,0);
                        (VOID) scrollb(2,0);
                        redraw(0);
                        return;
                }
        }
        /* NOTREACHED */
}

STATIC int
do_fsearch(cnt) long cnt; {     /* Forward search */

        do_search("/", cnt, 1);
}

STATIC int
do_bsearch(cnt) long cnt; {     /* Backward search */

        do_search("?", cnt, -1);
}

/*
 * Repeat last search in direction "dir"
 */

STATIC int
n_or_rn_search(cnt,dir) long cnt; int dir; {
        register char *p;

        if (dir == 1) {
                p = "/\r";
        }
        else if (dir == -1) {
                p = "?\r";
        }
        else {
                error("No previous pattern");
                return;
        }
        if (!stupid) clrbline();
        putline(p);
        flush();
        do_search((char *) 0, cnt, dir);
}

STATIC int
do_nsearch(cnt) long cnt; {     /* Repeat search in same direction */
        
        n_or_rn_search(cnt,searchdir);
}

STATIC int
do_rnsearch(cnt) long cnt; {    /* Repeat search in opposite direction */

        n_or_rn_search(cnt, -searchdir);
}

STATIC int shell(esc_ch, cnt) long cnt;
{
        register char *p;
        static char buf[2];

        buf[0] = esc_ch;
        if (p = readline(buf)) {
                shellescape(p, esc_ch);
                if (cnt >= 0 && !hardcopy) {
                        p = startcomm;
                        startcomm = 0;
                        ret_to_continue();
                        putline(TI);
                        if (!p) {
                                /*
                                 * Avoid double redraw.
                                 * After a "startcomm", a redraw will
                                 * take place anyway.
                                 */
                                redraw(1);
                        }
                }
        }
}

STATIC int
do_shell(cnt) long cnt; {       /* Execute a shell escape */
        shell('!', cnt);
}

STATIC int
do_pipe(cnt) long cnt; {        /* Execute a shell escape */
        shell('|', cnt);
}

/*ARGSUSED*/
STATIC int
do_writefile(cnt) long cnt; {   /* Write input to a file */
        register char *p;
        int fd;

        if ((p = readline("Filename: ")) == 0 || !*p) {
                /*
                 * No file name given
                 */
                return;
        }
# if USG_OPEN || BSD4_2_OPEN || POSIX_OPEN
        if ((fd = open(p,O_CREAT|O_EXCL|O_WRONLY,0644)) < 0) {
                if (errno == EEXIST) {
                        error("File exists");
                        return;
                }
                error("Could not open file");
                return;
        }
# else
        if (!access(p,0)) {
                error("File exists");
                return;
        }
        if ((fd = creat(p,0644)) < 0) {
                error("Could not open file");
                return;
        }
# endif
        wrt_fd(fd);
        (VOID) close(fd);
}

VOID
wrt_fd(fd)
{
        register long l = 1;
        register char *p = getline(l,0), *pbuf;
        char buf[1024];

        while (p) {
                pbuf = buf;
                while (p && pbuf < &buf[1024]) {
                        if (!*p) {
                                *pbuf++ = '\n';
                                p = getline(++l,0);
                        }
                        else *pbuf++ = *p++ & 0177;
                }
                if (write(fd, buf, pbuf - buf) < 0) {
                        error("Write failed");
                        break;
                }
        }
}

STATIC int
do_absolute(cnt) long cnt; {    /* Go to linenumber "cnt" */

        if (!getline(cnt,0)) {  /* Not there or interrupt */
                if (!interrupt) {
                        /*
                         * User did'nt give an interrupt, so the line number
                         * was too high. Go to the last line.
                         */
                        do_lline(cnt);
                }
                return;
        }
        (VOID) display(cnt,0,pagesize,1);
}

/*ARGSUSED*/
STATIC int
do_visit(cnt) long cnt; {       /* Visit a file */
        register char *p;
        static char fn[128];    /* Keep file name */

        if ((p = readline("Filename: ")) == 0) {
                return;
        }
        if (*p) {
                (VOID) strcpy(fn,p);
                visitfile(fn);
        }
        else {
                /*
                 * User typed a return. Visit the current file
                 */
                if (!(p = filenames[filecount])) {
                        error("No current file");
                        return;
                }
                visitfile(p);
        }
        (VOID) display(1L, 0, pagesize, 1);
}

/*ARGSUSED*/
STATIC int
do_error(cnt) long cnt; {       /* Called when user types wrong key sequence */

        error(currmap->k_help);
}

/*
 * Interface routine for displaying previous screen,
 * depending on cflag.
 */

STATIC int
prev_screen(sz,really) int sz, really; {
        register int retval;

        retval = scrollb(sz - 1, really && cflag);
        if (really && !cflag) {
                /*
                 * The previous call did not display anything, but at least we
                 * know where to start
                 */
                return display(scr_info.firstline, scr_info.nf, sz, 1);
        }
        return retval;
}

/*
 * Interface routine for displaying the next screen,
 * dependent on cflag.
 */

STATIC int
next_screen(sz,really) int sz, really; {

        register int t;
        register struct scr_info *p = &scr_info;

        if (cflag) {
                return scrollf(sz-1,really);
        }
        t = p->tail->cnt - 1;
        if (p->lastline == p->firstline) {
                t += p->nf;
        }
        return display(p->lastline, t, sz, really);
}

/*ARGSUSED*/
STATIC int
do_redraw(cnt) long cnt; {

        redraw(1);
}

STATIC int
page_size(cnt) unsigned cnt; {

        if (cnt) {
                if (cnt > maxpagesize) return maxpagesize;
                if (cnt < MINPAGESIZE) return MINPAGESIZE;
                return (int) cnt;
        }
        return pagesize;
}

STATIC int
do_forward(cnt) long cnt; {     /* Display next page */
        register int i;

        i = page_size((unsigned) cnt);
        if (status & EOFILE) {
                /*
                 * May seem strange, but actually a visit to the next file
                 * has already been done here
                 */
                (VOID) display(1L,0,i,1);
                return;
        }
        (VOID) next_screen(i,1);
}

STATIC int
do_backward(cnt) long cnt; {
        register int i, temp;

        i = page_size((unsigned) cnt);
        if (!(status & START)) {
                (VOID) prev_screen(i,1);
                return;
        }
        if (stdf < 0) {
                (VOID) display(1L,0,i,1);
                return;
        }
        /*
         * The next part is a bit clumsy.
         * We want to display the last page of the previous file (for which
         * a visit has already been done), but the pagesize may temporarily
         * be different because the command had a count
         */
        temp = pagesize;
        pagesize = i;
        do_lline(cnt);
        pagesize = temp;
}

/*ARGSUSED*/
STATIC int
do_firstline(cnt) long cnt; {   /* Go to start of input */

        do_absolute(1L);
}

STATIC int
do_lline(cnt) long cnt; {       /* Go to end of input */
        register int i = 0;
        register int j = pagesize - 1;

        if ((cnt = to_lastline()) < 0) {
                /*
                 * Interrupted by the user
                 */
                return;
        }
        /*
         * Display the page such that only the last line of the page is
         * a "~", independant of the pagesize
         */
        while (!(display(cnt,i,j,0) & EOFILE)) {
                /*
                 * The last line could of course be very long ...
                 */
                i+= j;
        }
        (VOID) scrollb(j - scr_info.tail->cnt, 0);
        redraw(0);
}

STATIC int
do_lf(cnt) long cnt; {          /* Display next line, or go to line */

        if (cnt) {              /* Go to line */
                do_absolute(cnt);
                return;
        }
        (VOID) scrollf(1,1);
}

STATIC int
do_upline(cnt) long cnt; {      /* Display previous line, or go to line */

        if (cnt) {              /* Go to line */
                do_absolute(cnt);
                return;
        }
        (VOID) scrollb(1,1);
}

STATIC int
do_skiplines(cnt) long cnt; {   /* Skip lines forwards */

        /* Should be interruptable ... */
        (VOID) scrollf((int) (cnt + maxpagesize - 1), 0);
        redraw(0);
}

STATIC int
do_bskiplines(cnt) long cnt; {  /* Skip lines backwards */

        /* Should be interruptable ... */
        (VOID) scrollb((int) (cnt + pagesize - 1), 0);
        redraw(0);
}

STATIC int
do_fscreens(cnt) long cnt; {    /* Skip screens forwards */

        do {
                if ((next_screen(pagesize,0) & EOFILE) || interrupt) break;
        } while (--cnt >= 0);
        redraw(0);
}

STATIC int
do_bscreens(cnt) long cnt; {    /* Skip screens backwards */

        do {
                if ((prev_screen(pagesize,0) & START) || interrupt) break;
        } while (--cnt >= 0);
        redraw(0);
}

STATIC int
scro_size(cnt) unsigned cnt; {

        if (cnt >= maxpagesize) return maxpagesize;
        if (cnt) return (int) cnt;
        return scrollsize;
}

STATIC int
do_f_scroll(cnt) long cnt; {    /* Scroll forwards */

        (VOID) scrollf(scro_size((unsigned) cnt),1);
}

STATIC int
do_b_scroll(cnt) long cnt; {    /* Scroll backwards */

        (VOID) scrollb(scro_size((unsigned) cnt),1);
}

STATIC int
do_previousfile(cnt) long cnt; {/* Visit previous file */

        if (nextfile(- (int) cnt)) {
                error("No (Nth) previous file");
                return;
        }
        redraw(0);
}

STATIC int
do_nextfile(cnt) long cnt; {    /* Visit next file */

        if (nextfile((int) cnt)) {
                error("No (Nth) next file");
                return;
        }
        redraw(0);
}

STATIC int do_lcomm();

/*
 * The next array is initialized, sorted on the first element of the structs,
 * so that we can perform binary search
 */
struct commands commands[] = {
{"",        0,      do_error,       ""},
{"",        0,      do_nocomm,      ""},
{"bf",      STICKY|NEEDS_COUNT,
                    do_previousfile,"Visit previous file"},
{"bl",      NEEDS_SCREEN|STICKY,
                    do_upline,      "Scroll one line up, or go to line"},
{"bot",     STICKY,
                    do_lline,       "Go to last line of the input"},
{"bp",      BACK|NEEDS_SCREEN|TOPREVFILE|STICKY,
                    do_backward,    "display previous page"},
{"bps",     SCREENSIZE_ADAPT|BACK|NEEDS_SCREEN|TOPREVFILE|STICKY,
                    do_backward,    "Display previous page, set pagesize"},
{"bs",      BACK|NEEDS_SCREEN|STICKY,
                    do_b_scroll,    "Scroll backwards"},
{"bse",     0,      do_bsearch,     "Search backwards for pattern"},
{"bsl",     BACK|NEEDS_SCREEN|STICKY|NEEDS_COUNT,
                    do_bskiplines,  "Skip lines backwards"},
{"bsp",     BACK|NEEDS_SCREEN|STICKY|NEEDS_COUNT,
                    do_bscreens,    "Skip screens backwards"},
{"bss",     SCROLLSIZE_ADAPT|BACK|NEEDS_SCREEN|STICKY,
                    do_b_scroll,    "Scroll backwards, set scrollsize"},
{"chm",     0,      do_chkm,        "Switch to other keymap"},
{"exg",     STICKY, exgmark,        "Exchange current page with mark"},
{"ff",      STICKY|NEEDS_COUNT,
                    do_nextfile,    "Visit next file"},
{"fl",      NEEDS_SCREEN|STICKY,
                    do_lf,          "Scroll one line down, or go to line"},
{"fp",      TONEXTFILE|AHEAD|STICKY,
                    do_forward,     "Display next page"},
{"fps",     SCREENSIZE_ADAPT|TONEXTFILE|AHEAD|STICKY,
                    do_forward,     "Display next page, set pagesize"},
{"fs",      AHEAD|NEEDS_SCREEN|STICKY,
                    do_f_scroll,    "Scroll forwards"},
{"fse",     0,      do_fsearch,     "Search forwards for pattern"},
{"fsl",     AHEAD|NEEDS_SCREEN|STICKY|NEEDS_COUNT,
                    do_skiplines,   "Skip lines forwards"},
{"fsp",     AHEAD|NEEDS_SCREEN|STICKY|NEEDS_COUNT,
                    do_fscreens,    "Skip screens forwards"},
{"fss",     SCROLLSIZE_ADAPT|AHEAD|NEEDS_SCREEN|STICKY,
                    do_f_scroll,    "Scroll forwards, set scrollsize"},
{"hlp",     0,      do_help,        "Give description of all commands"},
{"mar",     0,      setmark,        "Set a mark on the current page"},
{"nse",     STICKY, do_nsearch,     "Repeat the last search"},
{"nsr",     STICKY, do_rnsearch, "Repeat last search in other direction"},
{"pip",     ESC,    do_pipe,        "pipe input into shell command"},
{"qui",     0,      quit,           "Exit from yap"},
{"red",     0,      do_redraw,      "Redraw screen"},
{"rep",     0,      do_lcomm,       "Repeat last command"},
{"shl",     ESC,    do_shell,       "Execute a shell escape"},
{"tom",     0,      tomark,         "Go to mark"},
{"top",     STICKY, do_firstline,   "Go to the first line of the input"},
{"vis",     0,      do_visit,       "Visit a file"},
{"wrf",     0,      do_writefile,   "Write input to a file"},
};

/*
 * Lookup string "s" in the commands array, and return index.
 * return 0 if not found.
 */

int
lookup(s) char *s; {
        register struct commands *l, *u, *m;

        l = &commands[2];
        u = &commands[sizeof(commands) / sizeof(*u) - 1];
        do {
                /*
                 * Perform binary search
                 */
                m = l + (u - l) / 2;
                if (strcmp(s, m->c_cmd) > 0) l = m + 1;
                else u = m;
        } while (l < u);
        if (!strcmp(s, u->c_cmd)) return u - commands;
        return 0;
}

/*ARGSUSED*/
STATIC int
do_lcomm(cnt) long cnt; {       /* Repeat last command */

        if (!lastcomm) {
                error("No previous command");
                return;
        }
        do_comm(lastcomm, lastcount);
}

/*
 * Execute a command, with optional count "count".
 */

VOID
do_comm(comm, count) register int comm; register long count; {

        register struct commands *pcomm;
        register int temp;
        register int flags;

        pcomm = &commands[comm];
        flags = pcomm->c_flags;

        /*
         * Check the command.
         * If the last line of the file is displayed and the command goes
         * forwards and does'nt have the ability to go to the next file, it
         * is an error.
         * If the first line of the file is displayed and the command goes
         * backwards and does'nt have the ability to go to the previous file,
         * it is an error.
         * Also check wether we need the next or previous file. If so, get it.
         */
        if ((status & EOFILE) && (flags & AHEAD)) {
                if (qflag || !(flags & TONEXTFILE)) return;
                if (nextfile(1)) quit();
        }
        if ((status & START) && (flags & BACK)) {
                if (qflag || !(flags & TOPREVFILE)) return;
                if (nextfile(-1)) quit();
        }
        /*
         * Does the command stick around for LASTCOMM?
         */
        if (flags & STICKY) {
                lastcomm = comm;
                lastcount = count;
        }
        if (!count) {
                if (flags & NEEDS_COUNT) count = 1;
        }
        else {
                /*
                 * Does the command adapt the screensize?
                 */
                if (flags & SCREENSIZE_ADAPT) {
                        temp = maxpagesize;
                        if ((unsigned) count < temp) {
                                temp = count;
                        }
                        if (temp < MINPAGESIZE) {
                                temp = MINPAGESIZE;
                        }
                        count = 0;
                        pagesize = temp;
                }
                /*
                 * Does the command adapt the scrollsize?
                 */
                if (flags & SCROLLSIZE_ADAPT) {
                        temp = maxpagesize - 1;
                        if ((unsigned) count < temp) {
                                temp = (int) count;
                        }
                        scrollsize = temp;
                        count = 0;
                }
        }
        /*
         * Now execute the command.
         */
        (*(pcomm->c_func))(count);
}

---