mg-20161005004075500017510001751000000000001277516277600112015ustar00hanboetesmg-20161005/autoexec.c010064400017510001751000000045631276204442100132240ustar00hanboetes/* $OpenBSD: autoexec.c,v 1.17 2015/09/26 21:51:58 jasper Exp $ */ /* this file is in the public domain */ /* Author: Vincent Labrecque April 2002 */ #include #include #include #include #include #include #include "def.h" #include "funmap.h" struct autoexec { SLIST_ENTRY(autoexec) next; /* link in the linked list */ const char *pattern; /* Pattern to match to filenames */ PF fp; }; static SLIST_HEAD(, autoexec) autos; static int ready; #define AUTO_GROW 8 /* * Return a NULL terminated array of function pointers to be called * when we open a file that matches . The list must be free(ed) * after use. */ PF * find_autoexec(const char *fname) { PF *pfl, *npfl; int have, used; struct autoexec *ae; if (!ready) return (NULL); pfl = NULL; have = 0; used = 0; SLIST_FOREACH(ae, &autos, next) { if (fnmatch(ae->pattern, fname, 0) == 0) { if (used >= have) { npfl = reallocarray(pfl, have + AUTO_GROW + 1, sizeof(PF)); if (npfl == NULL) panic("out of memory"); pfl = npfl; have += AUTO_GROW; } pfl[used++] = ae->fp; } } if (used) pfl[used] = NULL; return (pfl); } int add_autoexec(const char *pattern, const char *func) { PF fp; struct autoexec *ae; if (!ready) { SLIST_INIT(&autos); ready = 1; } fp = name_function(func); if (fp == NULL) return (FALSE); ae = malloc(sizeof(*ae)); if (ae == NULL) return (FALSE); ae->fp = fp; ae->pattern = strdup(pattern); if (ae->pattern == NULL) { free(ae); return (FALSE); } SLIST_INSERT_HEAD(&autos, ae, next); return (TRUE); } /* * Register an auto-execute hook; that is, specify a filename pattern * (conforming to the shell's filename globbing rules) and an associated * function to execute when a file matching the specified pattern * is read into a buffer. */ /* ARGSUSED */ int auto_execute(int f, int n) { char patbuf[128], funcbuf[128], *patp, *funcp; int s; if ((patp = eread("Filename pattern: ", patbuf, sizeof(patbuf), EFNEW | EFCR)) == NULL) return (ABORT); else if (patp[0] == '\0') return (FALSE); if ((funcp = eread("Execute: ", funcbuf, sizeof(funcbuf), EFNEW | EFCR | EFFUNC)) == NULL) return (ABORT); else if (funcp[0] == '\0') return (FALSE); if ((s = add_autoexec(patp, funcp)) != TRUE) return (s); return (TRUE); } mg-20161005/basic.c010064400017510001751000000266761276204442100125010ustar00hanboetes/* $OpenBSD: basic.c,v 1.47 2015/10/10 09:13:14 lum Exp $ */ /* This file is in the public domain */ /* * Basic cursor motion commands. * * The routines in this file are the basic * command functions for moving the cursor around on * the screen, setting mark, and swapping dot with * mark. Only moves between lines, which might make the * current buffer framing bad, are hard. */ #include #include #include #include #include #include #include "def.h" /* * Go to beginning of line. */ /* ARGSUSED */ int gotobol(int f, int n) { if (n == 0) return (TRUE); curwp->w_doto = 0; return (TRUE); } /* * Move cursor backwards. Do the * right thing if the count is less than * 0. Error if you try to move back from * the beginning of the buffer. */ /* ARGSUSED */ int backchar(int f, int n) { struct line *lp; if (n < 0) return (forwchar(f, -n)); while (n--) { if (curwp->w_doto == 0) { if ((lp = lback(curwp->w_dotp)) == curbp->b_headp) { if (!(f & FFRAND)) { dobeep(); ewprintf("Beginning of buffer"); } return (FALSE); } curwp->w_dotp = lp; curwp->w_doto = llength(lp); curwp->w_rflag |= WFMOVE; curwp->w_dotline--; } else curwp->w_doto--; } return (TRUE); } /* * Go to end of line. */ /* ARGSUSED */ int gotoeol(int f, int n) { if (n == 0) return (TRUE); curwp->w_doto = llength(curwp->w_dotp); return (TRUE); } /* * Move cursor forwards. Do the * right thing if the count is less than * 0. Error if you try to move forward * from the end of the buffer. */ /* ARGSUSED */ int forwchar(int f, int n) { if (n < 0) return (backchar(f, -n)); while (n--) { if (curwp->w_doto == llength(curwp->w_dotp)) { curwp->w_dotp = lforw(curwp->w_dotp); if (curwp->w_dotp == curbp->b_headp) { curwp->w_dotp = lback(curwp->w_dotp); if (!(f & FFRAND)) { dobeep(); ewprintf("End of buffer"); } return (FALSE); } curwp->w_doto = 0; curwp->w_dotline++; curwp->w_rflag |= WFMOVE; } else curwp->w_doto++; } return (TRUE); } /* * Go to the beginning of the * buffer. Setting WFFULL is conservative, * but almost always the case. */ int gotobob(int f, int n) { (void) setmark(f, n); curwp->w_dotp = bfirstlp(curbp); curwp->w_doto = 0; curwp->w_rflag |= WFFULL; curwp->w_dotline = 1; return (TRUE); } /* * Go to the end of the buffer. Leave dot 3 lines from the bottom of the * window if buffer length is longer than window length; same as emacs. * Setting WFFULL is conservative, but almost always the case. */ int gotoeob(int f, int n) { struct line *lp; (void) setmark(f, n); curwp->w_dotp = blastlp(curbp); curwp->w_doto = llength(curwp->w_dotp); curwp->w_dotline = curwp->w_bufp->b_lines; lp = curwp->w_dotp; n = curwp->w_ntrows - 3; if (n < curwp->w_bufp->b_lines && n >= 3) { while (n--) curwp->w_dotp = lback(curwp->w_dotp); curwp->w_linep = curwp->w_dotp; curwp->w_dotp = lp; } curwp->w_rflag |= WFFULL; return (TRUE); } /* * Move forward by full lines. * If the number of lines to move is less * than zero, call the backward line function to * actually do it. The last command controls how * the goal column is set. */ /* ARGSUSED */ int forwline(int f, int n) { struct line *dlp; if (n < 0) return (backline(f | FFRAND, -n)); if ((dlp = curwp->w_dotp) == curbp->b_headp) { if (!(f & FFRAND)) { dobeep(); ewprintf("End of buffer"); } return(TRUE); } if ((lastflag & CFCPCN) == 0) /* Fix goal. */ setgoal(); thisflag |= CFCPCN; if (n == 0) return (TRUE); while (n--) { dlp = lforw(dlp); if (dlp == curbp->b_headp) { curwp->w_dotp = lback(dlp); curwp->w_doto = llength(curwp->w_dotp); curwp->w_rflag |= WFMOVE; if (!(f & FFRAND)) { dobeep(); ewprintf("End of buffer"); } return (TRUE); } curwp->w_dotline++; } curwp->w_rflag |= WFMOVE; curwp->w_dotp = dlp; curwp->w_doto = getgoal(dlp); return (TRUE); } /* * This function is like "forwline", but * goes backwards. The scheme is exactly the same. * Check for arguments that are less than zero and * call your alternate. Figure out the new line and * call "movedot" to perform the motion. */ /* ARGSUSED */ int backline(int f, int n) { struct line *dlp; if (n < 0) return (forwline(f | FFRAND, -n)); if ((lastflag & CFCPCN) == 0) /* Fix goal. */ setgoal(); thisflag |= CFCPCN; dlp = curwp->w_dotp; if (lback(dlp) == curbp->b_headp) { if (!(f & FFRAND)) { dobeep(); ewprintf("Beginning of buffer"); } return(TRUE); } while (n-- && lback(dlp) != curbp->b_headp) { dlp = lback(dlp); curwp->w_dotline--; } if (n > 0 && !(f & FFRAND)) { dobeep(); ewprintf("Beginning of buffer"); } curwp->w_dotp = dlp; curwp->w_doto = getgoal(dlp); curwp->w_rflag |= WFMOVE; return (TRUE); } /* * Set the current goal column, which is saved in the external variable * "curgoal", to the current cursor column. The column is never off * the edge of the screen; it's more like display then show position. */ void setgoal(void) { curgoal = getcolpos(curwp); /* Get the position. */ /* we can now display past end of display, don't chop! */ } /* * This routine looks at a line (pointed * to by the LINE pointer "dlp") and the current * vertical motion goal column (set by the "setgoal" * routine above) and returns the best offset to use * when a vertical motion is made into the line. */ int getgoal(struct line *dlp) { int c, i, col = 0; char tmp[5]; for (i = 0; i < llength(dlp); i++) { c = lgetc(dlp, i); if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif ) { col |= 0x07; col++; } else if (ISCTRL(c) != FALSE) { col += 2; } else if (isprint(c)) col++; else { col += snprintf(tmp, sizeof(tmp), "\\%o", c); } if (col > curgoal) break; } return (i); } /* * Scroll forward by a specified number * of lines, or by a full page if no argument. * The "2" is the window overlap (this is the default * value from ITS EMACS). Because the top line in * the window is zapped, we have to do a hard * update and get it back. */ /* ARGSUSED */ int forwpage(int f, int n) { struct line *lp; if (!(f & FFARG)) { n = curwp->w_ntrows - 2; /* Default scroll. */ if (n <= 0) /* Forget the overlap */ n = 1; /* if tiny window. */ } else if (n < 0) return (backpage(f | FFRAND, -n)); lp = curwp->w_linep; while (n--) if ((lp = lforw(lp)) == curbp->b_headp) { dobeep(); ewprintf("End of buffer"); return(TRUE); } curwp->w_linep = lp; curwp->w_rflag |= WFFULL; /* if in current window, don't move dot */ for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp)) if (lp == curwp->w_dotp) return (TRUE); /* Advance the dot the slow way, for line nos */ while (curwp->w_dotp != curwp->w_linep) { curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_dotline++; } curwp->w_doto = 0; return (TRUE); } /* * This command is like "forwpage", * but it goes backwards. The "2", like above, * is the overlap between the two windows. The * value is from the ITS EMACS manual. The * hard update is done because the top line in * the window is zapped. */ /* ARGSUSED */ int backpage(int f, int n) { struct line *lp, *lp2; if (!(f & FFARG)) { n = curwp->w_ntrows - 2; /* Default scroll. */ if (n <= 0) /* Don't blow up if the */ return (backline(f, 1));/* window is tiny. */ } else if (n < 0) return (forwpage(f | FFRAND, -n)); lp = lp2 = curwp->w_linep; while (n-- && lback(lp) != curbp->b_headp) { lp = lback(lp); } if (lp == curwp->w_linep) { dobeep(); ewprintf("Beginning of buffer"); } curwp->w_linep = lp; curwp->w_rflag |= WFFULL; /* if in current window, don't move dot */ for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp)) if (lp == curwp->w_dotp) return (TRUE); lp2 = lforw(lp2); /* Move the dot the slow way, for line nos */ while (curwp->w_dotp != lp2) { if (curwp->w_dotline <= curwp->w_ntrows) goto out; curwp->w_dotp = lback(curwp->w_dotp); curwp->w_dotline--; } out: curwp->w_doto = 0; return (TRUE); } /* * These functions are provided for compatibility with Gosling's Emacs. They * are used to scroll the display up (or down) one line at a time. */ int forw1page(int f, int n) { if (!(f & FFARG)) { n = 1; f = FFUNIV; } forwpage(f | FFRAND, n); return (TRUE); } int back1page(int f, int n) { if (!(f & FFARG)) { n = 1; f = FFUNIV; } backpage(f | FFRAND, n); return (TRUE); } /* * Page the other window. Check to make sure it exists, then * nextwind, forwpage and restore window pointers. */ int pagenext(int f, int n) { struct mgwin *wp; if (wheadp->w_wndp == NULL) { dobeep(); ewprintf("No other window"); return (FALSE); } wp = curwp; (void) nextwind(f, n); (void) forwpage(f, n); curwp = wp; curbp = wp->w_bufp; return (TRUE); } /* * Internal set mark routine, used by other functions (daveb). */ void isetmark(void) { curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; curwp->w_markline = curwp->w_dotline; } /* * Set the mark in the current window * to the value of dot. A message is written to * the echo line. (ewprintf knows about macros) */ /* ARGSUSED */ int setmark(int f, int n) { isetmark(); ewprintf("Mark set"); return (TRUE); } /* Clear the mark, if set. */ /* ARGSUSED */ int clearmark(int f, int n) { if (!curwp->w_markp) return (FALSE); curwp->w_markp = NULL; curwp->w_marko = 0; curwp->w_markline = 0; return (TRUE); } /* * Swap the values of "dot" and "mark" in * the current window. This is pretty easy, because * all of the hard work gets done by the standard routine * that moves the mark about. The only possible * error is "no mark". */ /* ARGSUSED */ int swapmark(int f, int n) { struct line *odotp; int odoto, odotline; if (curwp->w_markp == NULL) { dobeep(); ewprintf("No mark in this window"); return (FALSE); } odotp = curwp->w_dotp; odoto = curwp->w_doto; odotline = curwp->w_dotline; curwp->w_dotp = curwp->w_markp; curwp->w_doto = curwp->w_marko; curwp->w_dotline = curwp->w_markline; curwp->w_markp = odotp; curwp->w_marko = odoto; curwp->w_markline = odotline; curwp->w_rflag |= WFMOVE; return (TRUE); } /* * Go to a specific line, mostly for * looking up errors in C programs, which give the * error a line number. If an argument is present, then * it is the line number, else prompt for a line number * to use. */ /* ARGSUSED */ int gotoline(int f, int n) { char buf[32], *bufp; const char *err; if (!(f & FFARG)) { if ((bufp = eread("Goto line: ", buf, sizeof(buf), EFNUL | EFNEW | EFCR)) == NULL) return (ABORT); if (bufp[0] == '\0') return (ABORT); n = (int)strtonum(buf, INT_MIN, INT_MAX, &err); if (err) { dobeep(); ewprintf("Line number %s", err); return (FALSE); } } return(setlineno(n)); } /* * Set the line number and switch to it. */ int setlineno(int n) { struct line *clp; if (n >= 0) { if (n == 0) n++; curwp->w_dotline = n; clp = lforw(curbp->b_headp); /* "clp" is first line */ while (--n > 0) { if (lforw(clp) == curbp->b_headp) { curwp->w_dotline = curwp->w_bufp->b_lines; break; } clp = lforw(clp); } } else { curwp->w_dotline = curwp->w_bufp->b_lines + n; clp = lback(curbp->b_headp); /* "clp" is last line */ while (n < 0) { if (lback(clp) == curbp->b_headp) { curwp->w_dotline = 1; break; } clp = lback(clp); n++; } } curwp->w_dotp = clp; curwp->w_doto = 0; curwp->w_rflag |= WFMOVE; return (TRUE); } mg-20161005/bell.c010064400017510001751000000016111276204442100123140ustar00hanboetes/* $OpenBSD: bell.c,v 1.4 2016/01/03 19:37:08 lum Exp $ */ /* * This file is in the public domain. * * Author: Mark Lumsden * */ /* * Control how mg communicates with the user. */ #include #include #include #include #include "def.h" #include "macro.h" void bellinit(void) { doaudiblebell = 1; dovisiblebell = 0; } void dobeep(void) { if (doaudiblebell) { ttbeep(); } if (dovisiblebell) { sgarbf = TRUE; update(CNONE); if (inmacro) /* avoid delaying macro execution. */ return; usleep(50000); } } /* ARGSUSED */ int toggleaudiblebell(int f, int n) { if (f & FFARG) doaudiblebell = n > 0; else doaudiblebell = !doaudiblebell; return (TRUE); } /* ARGSUSED */ int togglevisiblebell(int f, int n) { if (f & FFARG) dovisiblebell = n > 0; else dovisiblebell = !dovisiblebell; return (TRUE); } mg-20161005/buffer.c010064400017510001751000000553761276555461100127020ustar00hanboetes/* $OpenBSD: buffer.c,v 1.102 2016/09/07 11:42:01 lum Exp $ */ /* This file is in the public domain. */ /* * Buffer handling. */ #include #include #include #include #include #include #include #include #include #include "def.h" #include "kbd.h" /* needed for modes */ #define DIFFTOOL "/usr/bin/diff" static struct buffer *makelist(void); static struct buffer *bnew(const char *); static int usebufname(const char *); /* Flag for global working dir */ extern int globalwd; /* ARGSUSED */ int togglereadonly(int f, int n) { int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (!(curbp->b_flag & BFREADONLY)) curbp->b_flag |= BFREADONLY; else { curbp->b_flag &= ~BFREADONLY; if (curbp->b_flag & BFCHG) ewprintf("Warning: Buffer was modified"); } curwp->w_rflag |= WFMODE; return (TRUE); } /* Switch to the named buffer. * If no name supplied, switch to the default (alternate) buffer. */ int usebufname(const char *bufp) { struct buffer *bp = NULL; if (bufp == NULL) { if ((bp = bfind("*scratch*", TRUE)) == NULL) return(FALSE); } else if (bufp[0] == '\0' && curbp->b_altb != NULL) bp = curbp->b_altb; else if ((bp = bfind(bufp, TRUE)) == NULL) return (FALSE); /* and put it in current window */ curbp = bp; return (showbuffer(bp, curwp, WFFRAME | WFFULL)); } /* * Attach a buffer to a window. The values of dot and mark come * from the buffer if the use count is 0. Otherwise, they come * from some other window. *scratch* is the default alternate * buffer. */ /* ARGSUSED */ int usebuffer(int f, int n) { char bufn[NBUFN], *bufp; /* Get buffer to use from user */ if (curbp->b_altb == NULL) bufp = eread("Switch to buffer: ", bufn, NBUFN, EFNEW | EFBUF); else bufp = eread("Switch to buffer: (default %s) ", bufn, NBUFN, EFNUL | EFNEW | EFBUF, curbp->b_altb->b_bname); return (usebufname(bufp)); } /* * pop to buffer asked for by the user. */ /* ARGSUSED */ int poptobuffer(int f, int n) { struct buffer *bp; struct mgwin *wp; char bufn[NBUFN], *bufp; /* Get buffer to use from user */ if ((curbp->b_altb == NULL) && ((curbp->b_altb = bfind("*scratch*", TRUE)) == NULL)) bufp = eread("Switch to buffer in other window: ", bufn, NBUFN, EFNEW | EFBUF); else bufp = eread("Switch to buffer in other window: (default %s) ", bufn, NBUFN, EFNUL | EFNEW | EFBUF, curbp->b_altb->b_bname); if (bufp == NULL) return (ABORT); if (bufp[0] == '\0' && curbp->b_altb != NULL) bp = curbp->b_altb; else if ((bp = bfind(bufn, TRUE)) == NULL) return (FALSE); if (bp == curbp) return (splitwind(f, n)); /* and put it in a new, non-ephemeral window */ if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; curwp = wp; return (TRUE); } /* * Dispose of a buffer, by name. * Ask for the name (unless called by dired mode). Look it up (don't * get too upset if it isn't there at all!). Clear the buffer (ask * if the buffer has been changed). Then free the header * line and the buffer header. Bound to "C-x k". */ /* ARGSUSED */ int killbuffer_cmd(int f, int n) { struct buffer *bp; char bufn[NBUFN], *bufp; if (f & FFRAND) /* dired mode 'q' */ bp = curbp; else if ((bufp = eread("Kill buffer: (default %s) ", bufn, NBUFN, EFNUL | EFNEW | EFBUF, curbp->b_bname)) == NULL) return (ABORT); else if (bufp[0] == '\0') bp = curbp; else if ((bp = bfind(bufn, FALSE)) == NULL) return (FALSE); return (killbuffer(bp)); } int killbuffer(struct buffer *bp) { struct buffer *bp1; struct buffer *bp2; struct mgwin *wp; int s; struct undo_rec *rec; /* * Find some other buffer to display. Try the alternate buffer, * then the first different buffer in the buffer list. If there's * only one buffer, create buffer *scratch* and make it the alternate * buffer. Return if *scratch* is only buffer... */ if ((bp1 = bp->b_altb) == NULL) { /* only one buffer. see if it's *scratch* */ if (bp == bfind("*scratch*", FALSE)) return (TRUE); /* create *scratch* for alternate buffer */ if ((bp1 = bfind("*scratch*", TRUE)) == NULL) return (FALSE); } if ((s = bclear(bp)) != TRUE) return (s); for (wp = wheadp; bp->b_nwnd > 0; wp = wp->w_wndp) { if (wp->w_bufp == bp) { bp2 = bp1->b_altb; /* save alternate buffer */ if (showbuffer(bp1, wp, WFMODE | WFFRAME | WFFULL)) bp1->b_altb = bp2; else bp1 = bp2; } } if (bp == curbp) curbp = bp1; free(bp->b_headp); /* Release header line. */ bp2 = NULL; /* Find the header. */ bp1 = bheadp; while (bp1 != bp) { if (bp1->b_altb == bp) bp1->b_altb = (bp->b_altb == bp1) ? NULL : bp->b_altb; bp2 = bp1; bp1 = bp1->b_bufp; } bp1 = bp1->b_bufp; /* Next one in chain. */ if (bp2 == NULL) /* Unlink it. */ bheadp = bp1; else bp2->b_bufp = bp1; while (bp1 != NULL) { /* Finish with altb's */ if (bp1->b_altb == bp) bp1->b_altb = (bp->b_altb == bp1) ? NULL : bp->b_altb; bp1 = bp1->b_bufp; } while ((rec = TAILQ_FIRST(&bp->b_undo))) { TAILQ_REMOVE(&bp->b_undo, rec, next); free_undo_record(rec); } free(bp->b_bname); /* Release name block */ free(bp); /* Release buffer block */ return (TRUE); } /* * Save some buffers - just call anycb with the arg flag. */ /* ARGSUSED */ int savebuffers(int f, int n) { if (anycb(f) == ABORT) return (ABORT); return (TRUE); } /* * Listing buffers. */ static int listbuf_ncol; static int listbuf_goto_buffer(int f, int n); static int listbuf_goto_buffer_one(int f, int n); static int listbuf_goto_buffer_helper(int f, int n, int only); static PF listbuf_pf[] = { listbuf_goto_buffer }; static PF listbuf_one[] = { listbuf_goto_buffer_one }; static struct KEYMAPE (2) listbufmap = { 2, 2, rescan, { { CCHR('M'), CCHR('M'), listbuf_pf, NULL }, { '1', '1', listbuf_one, NULL } } }; /* * Display the buffer list. This is done * in two parts. The "makelist" routine figures out * the text, and puts it in a buffer. "popbuf" * then pops the data onto the screen. Bound to * "C-X C-B". */ /* ARGSUSED */ int listbuffers(int f, int n) { static int initialized = 0; struct buffer *bp; struct mgwin *wp; if (!initialized) { maps_add((KEYMAP *)&listbufmap, "listbufmap"); initialized = 1; } if ((bp = makelist()) == NULL || (wp = popbuf(bp, WNONE)) == NULL) return (FALSE); wp->w_dotp = bp->b_dotp; /* fix up if window already on screen */ wp->w_doto = bp->b_doto; bp->b_modes[0] = name_mode("fundamental"); bp->b_modes[1] = name_mode("listbufmap"); bp->b_nmodes = 1; return (TRUE); } /* * This routine rebuilds the text for the * list buffers command. Return pointer * to new list if everything works. * Return NULL if there is an error (if * there is no memory). */ static struct buffer * makelist(void) { int w = ncol / 2; struct buffer *bp, *blp; struct line *lp; if ((blp = bfind("*Buffer List*", TRUE)) == NULL) return (NULL); if (bclear(blp) != TRUE) return (NULL); blp->b_flag &= ~BFCHG; /* Blow away old. */ blp->b_flag |= BFREADONLY; listbuf_ncol = ncol; /* cache ncol for listbuf_goto_buffer */ if (addlinef(blp, "%-*s%s", w, " MR Buffer", "Size File") == FALSE || addlinef(blp, "%-*s%s", w, " -- ------", "---- ----") == FALSE) return (NULL); for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { RSIZE nbytes; nbytes = 0; /* Count bytes in buf. */ if (bp != blp) { lp = bfirstlp(bp); while (lp != bp->b_headp) { nbytes += llength(lp) + 1; lp = lforw(lp); } if (nbytes) nbytes--; /* no bonus newline */ } if (addlinef(blp, "%c%c%c %-*.*s%c%-6d %-*s", (bp == curbp) ? '.' : ' ', /* current buffer ? */ ((bp->b_flag & BFCHG) != 0) ? '*' : ' ', /* changed ? */ ((bp->b_flag & BFREADONLY) != 0) ? ' ' : '*', w - 5, /* four chars already written */ w - 5, /* four chars already written */ bp->b_bname, /* buffer name */ strlen(bp->b_bname) < w - 5 ? ' ' : '$', /* truncated? */ nbytes, /* buffer size */ w - 7, /* seven chars already written */ bp->b_fname) == FALSE) return (NULL); } blp->b_dotp = bfirstlp(blp); /* put dot at beginning of * buffer */ blp->b_doto = 0; return (blp); /* All done */ } static int listbuf_goto_buffer(int f, int n) { return (listbuf_goto_buffer_helper(f, n, 0)); } static int listbuf_goto_buffer_one(int f, int n) { return (listbuf_goto_buffer_helper(f, n, 1)); } static int listbuf_goto_buffer_helper(int f, int n, int only) { struct buffer *bp; struct mgwin *wp; char *line = NULL; int i, ret = FALSE; if (curwp->w_dotp->l_text[listbuf_ncol/2 - 1] == '$') { dobeep(); ewprintf("buffer name truncated"); return (FALSE); } if ((line = malloc(listbuf_ncol/2)) == NULL) return (FALSE); memcpy(line, curwp->w_dotp->l_text + 4, listbuf_ncol/2 - 5); for (i = listbuf_ncol/2 - 6; i > 0; i--) { if (line[i] != ' ') { line[i + 1] = '\0'; break; } } if (i == 0) goto cleanup; for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (strcmp(bp->b_bname, line) == 0) break; } if (bp == NULL) goto cleanup; if ((wp = popbuf(bp, WNONE)) == NULL) goto cleanup; curbp = bp; curwp = wp; if (only) ret = (onlywind(FFRAND, 1)); else ret = TRUE; cleanup: free(line); return (ret); } /* * The argument "fmt" points to a format string. Append this line to the * buffer. Handcraft the EOL on the end. Return TRUE if it worked and * FALSE if you ran out of room. */ int addlinef(struct buffer *bp, char *fmt, ...) { va_list ap; struct line *lp; if ((lp = lalloc(0)) == NULL) return (FALSE); va_start(ap, fmt); if (vasprintf(&lp->l_text, fmt, ap) == -1) { lfree(lp); va_end(ap); return (FALSE); } lp->l_used = strlen(lp->l_text); va_end(ap); bp->b_headp->l_bp->l_fp = lp; /* Hook onto the end */ lp->l_bp = bp->b_headp->l_bp; bp->b_headp->l_bp = lp; lp->l_fp = bp->b_headp; bp->b_lines++; return (TRUE); } /* * Look through the list of buffers, giving the user a chance to save them. * Return TRUE if there are any changed buffers afterwards. Buffers that don't * have an associated file don't count. Return FALSE if there are no changed * buffers. Return ABORT if an error occurs or if the user presses c-g. */ int anycb(int f) { struct buffer *bp; int s = FALSE, save = FALSE, save2 = FALSE, ret; char pbuf[NFILEN + 11]; for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (*(bp->b_fname) != '\0' && (bp->b_flag & BFCHG) != 0) { ret = snprintf(pbuf, sizeof(pbuf), "Save file %s", bp->b_fname); if (ret < 0 || ret >= sizeof(pbuf)) { dobeep(); ewprintf("Error: filename too long!"); return (UERROR); } if ((f == TRUE || (save = eyorn(pbuf)) == TRUE) && (save2 = buffsave(bp)) == TRUE) { bp->b_flag &= ~BFCHG; upmodes(bp); } else { if (save2 == FIOERR) return (save2); s = TRUE; } if (save == ABORT) return (save); save = TRUE; } } if (save == FALSE /* && kbdmop == NULL */ ) /* experimental */ ewprintf("(No files need saving)"); return (s); } /* * Search for a buffer, by name. * If not found, and the "cflag" is TRUE, * create a new buffer. Return pointer to the found * (or new) buffer. */ struct buffer * bfind(const char *bname, int cflag) { struct buffer *bp; bp = bheadp; while (bp != NULL) { if (strcmp(bname, bp->b_bname) == 0) return (bp); bp = bp->b_bufp; } if (cflag != TRUE) return (NULL); bp = bnew(bname); return (bp); } /* * Create a new buffer and put it in the list of * all buffers. */ static struct buffer * bnew(const char *bname) { struct buffer *bp; struct line *lp; int i; size_t len; bp = calloc(1, sizeof(struct buffer)); if (bp == NULL) { dobeep(); ewprintf("Can't get %d bytes", sizeof(struct buffer)); return (NULL); } if ((lp = lalloc(0)) == NULL) { free(bp); return (NULL); } bp->b_altb = bp->b_bufp = NULL; bp->b_dotp = lp; bp->b_doto = 0; bp->b_markp = NULL; bp->b_marko = 0; bp->b_flag = defb_flag; /* if buffer name starts and ends with '*', we ignore changes */ len = strlen(bname); if (len) { if (bname[0] == '*' && bname[len - 1] == '*') bp->b_flag |= BFIGNDIRTY; } bp->b_nwnd = 0; bp->b_headp = lp; bp->b_nmodes = defb_nmodes; TAILQ_INIT(&bp->b_undo); bp->b_undoptr = NULL; i = 0; do { bp->b_modes[i] = defb_modes[i]; } while (i++ < defb_nmodes); bp->b_fname[0] = '\0'; bp->b_cwd[0] = '\0'; bzero(&bp->b_fi, sizeof(bp->b_fi)); lp->l_fp = lp; lp->l_bp = lp; bp->b_bufp = bheadp; bheadp = bp; bp->b_dotline = bp->b_markline = 1; bp->b_lines = 1; if ((bp->b_bname = strdup(bname)) == NULL) { dobeep(); ewprintf("Can't get %d bytes", strlen(bname) + 1); return (NULL); } return (bp); } /* * This routine blows away all of the text * in a buffer. If the buffer is marked as changed * then we ask if it is ok to blow it away; this is * to save the user the grief of losing text. The * window chain is nearly always wrong if this gets * called; the caller must arrange for the updates * that are required. Return TRUE if everything * looks good. */ int bclear(struct buffer *bp) { struct line *lp; int s; /* Has buffer changed, and do we care? */ if (!(bp->b_flag & BFIGNDIRTY) && (bp->b_flag & BFCHG) != 0 && (s = eyesno("Buffer modified; kill anyway")) != TRUE) return (s); bp->b_flag &= ~BFCHG; /* Not changed */ while ((lp = lforw(bp->b_headp)) != bp->b_headp) lfree(lp); bp->b_dotp = bp->b_headp; /* Fix dot */ bp->b_doto = 0; bp->b_markp = NULL; /* Invalidate "mark" */ bp->b_marko = 0; bp->b_dotline = bp->b_markline = 1; bp->b_lines = 1; return (TRUE); } /* * Display the given buffer in the given window. Flags indicated * action on redisplay. Update modified flag so insert loop can check it. */ int showbuffer(struct buffer *bp, struct mgwin *wp, int flags) { struct buffer *obp; struct mgwin *owp; /* Ensure file has not been modified elsewhere */ if (fchecktime(bp) != TRUE) bp->b_flag |= BFDIRTY; if (wp->w_bufp == bp) { /* Easy case! */ wp->w_rflag |= flags; return (TRUE); } /* First, detach the old buffer from the window */ if ((bp->b_altb = obp = wp->w_bufp) != NULL) { if (--obp->b_nwnd == 0) { obp->b_dotp = wp->w_dotp; obp->b_doto = wp->w_doto; obp->b_markp = wp->w_markp; obp->b_marko = wp->w_marko; obp->b_dotline = wp->w_dotline; obp->b_markline = wp->w_markline; } } /* Now, attach the new buffer to the window */ wp->w_bufp = bp; if (bp->b_nwnd++ == 0) { /* First use. */ wp->w_dotp = bp->b_dotp; wp->w_doto = bp->b_doto; wp->w_markp = bp->b_markp; wp->w_marko = bp->b_marko; wp->w_dotline = bp->b_dotline; wp->w_markline = bp->b_markline; } else /* already on screen, steal values from other window */ for (owp = wheadp; owp != NULL; owp = wp->w_wndp) if (wp->w_bufp == bp && owp != wp) { wp->w_dotp = owp->w_dotp; wp->w_doto = owp->w_doto; wp->w_markp = owp->w_markp; wp->w_marko = owp->w_marko; wp->w_dotline = owp->w_dotline; wp->w_markline = owp->w_markline; break; } wp->w_rflag |= WFMODE | flags; return (TRUE); } /* * Augment a buffer name with a number, if necessary * * If more than one file of the same basename() is open, * the additional buffers are named "file<2>", "file<3>", and * so forth. This function adjusts a buffer name to * include the number, if necessary. */ int augbname(char *bn, const char *fn, size_t bs) { int count; size_t remain, len; if ((len = xbasename(bn, fn, bs)) >= bs) return (FALSE); remain = bs - len; for (count = 2; bfind(bn, FALSE) != NULL; count++) snprintf(bn + len, remain, "<%d>", count); return (TRUE); } /* * Pop the buffer we got passed onto the screen. * Returns a status. */ struct mgwin * popbuf(struct buffer *bp, int flags) { struct mgwin *wp; if (bp->b_nwnd == 0) { /* Not on screen yet. */ /* * Pick a window for a pop-up. * If only one window, split the screen. * Flag the new window as ephemeral */ if (wheadp->w_wndp == NULL && splitwind(FFOTHARG, flags) == FALSE) return (NULL); /* * Pick the uppermost window that isn't * the current window. An LRU algorithm * might be better. Return a pointer, or NULL on error. */ wp = wheadp; while (wp != NULL && wp == curwp) wp = wp->w_wndp; } else { for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == bp) { wp->w_rflag |= WFFULL | WFFRAME; return (wp); } } } if (!wp) return (NULL); if (showbuffer(bp, wp, WFFULL) != TRUE) return (NULL); return (wp); } /* * Insert another buffer at dot. Very useful. */ /* ARGSUSED */ int bufferinsert(int f, int n) { struct buffer *bp; struct line *clp; int clo, nline; char bufn[NBUFN], *bufp; /* Get buffer to use from user */ if (curbp->b_altb != NULL) bufp = eread("Insert buffer: (default %s) ", bufn, NBUFN, EFNUL | EFNEW | EFBUF, curbp->b_altb->b_bname); else bufp = eread("Insert buffer: ", bufn, NBUFN, EFNEW | EFBUF); if (bufp == NULL) return (ABORT); if (bufp[0] == '\0' && curbp->b_altb != NULL) bp = curbp->b_altb; else if ((bp = bfind(bufn, FALSE)) == NULL) return (FALSE); if (bp == curbp) { dobeep(); ewprintf("Cannot insert buffer into self"); return (FALSE); } /* insert the buffer */ nline = 0; clp = bfirstlp(bp); for (;;) { for (clo = 0; clo < llength(clp); clo++) if (linsert(1, lgetc(clp, clo)) == FALSE) return (FALSE); if ((clp = lforw(clp)) == bp->b_headp) break; if (enewline(FFRAND, 1) == FALSE) /* fake newline */ return (FALSE); nline++; } if (nline == 1) ewprintf("[Inserted 1 line]"); else ewprintf("[Inserted %d lines]", nline); clp = curwp->w_linep; /* cosmetic adjustment */ if (curwp->w_dotp == clp) { /* for offscreen insert */ while (nline-- && lback(clp) != curbp->b_headp) clp = lback(clp); curwp->w_linep = clp; /* adjust framing. */ curwp->w_rflag |= WFFULL; } return (TRUE); } /* * Turn off the dirty bit on this buffer. */ /* ARGSUSED */ int notmodified(int f, int n) { struct mgwin *wp; curbp->b_flag &= ~BFCHG; wp = wheadp; /* Update mode lines. */ while (wp != NULL) { if (wp->w_bufp == curbp) wp->w_rflag |= WFMODE; wp = wp->w_wndp; } ewprintf("Modification-flag cleared"); return (TRUE); } /* * Popbuf and set all windows to top of buffer. */ int popbuftop(struct buffer *bp, int flags) { struct mgwin *wp; bp->b_dotp = bfirstlp(bp); bp->b_doto = 0; if (bp->b_nwnd != 0) { for (wp = wheadp; wp != NULL; wp = wp->w_wndp) if (wp->w_bufp == bp) { wp->w_dotp = bp->b_dotp; wp->w_doto = 0; wp->w_rflag |= WFFULL; } } return (popbuf(bp, flags) != NULL); } /* * Return the working directory for the current buffer, terminated * with a '/'. First, try to extract it from the current buffer's * filename. If that fails, use global cwd. */ int getbufcwd(char *path, size_t plen) { char cwd[NFILEN]; if (plen == 0) return (FALSE); if (globalwd == FALSE && curbp->b_cwd[0] != '\0') { (void)strlcpy(path, curbp->b_cwd, plen); } else { if (getcwdir(cwd, sizeof(cwd)) == FALSE) goto error; (void)strlcpy(path, cwd, plen); } return (TRUE); error: path[0] = '\0'; return (FALSE); } /* * Ensures a buffer has not been modified elsewhere; e.g. on disk. * Prompt the user if it has. * Returns TRUE if it has NOT (i.e. buffer is ok to edit). * FALSE or ABORT otherwise */ int checkdirty(struct buffer *bp) { int s; if ((bp->b_flag & (BFCHG | BFDIRTY)) == 0) if (fchecktime(bp) != TRUE) bp->b_flag |= BFDIRTY; if ((bp->b_flag & (BFDIRTY | BFIGNDIRTY)) == BFDIRTY) { s = eynorr("File changed on disk; really edit the buffer"); switch (s) { case TRUE: bp->b_flag &= ~BFDIRTY; bp->b_flag |= BFIGNDIRTY; return (TRUE); case REVERT: dorevert(); return (FALSE); default: return (s); } } return (TRUE); } /* * Revert the current buffer to whatever is on disk. */ /* ARGSUSED */ int revertbuffer(int f, int n) { char fbuf[NFILEN + 32]; if (curbp->b_fname[0] == 0) { dobeep(); ewprintf("Cannot revert buffer not associated with any files."); return (FALSE); } snprintf(fbuf, sizeof(fbuf), "Revert buffer from file %s", curbp->b_fname); if (eyorn(fbuf) == TRUE) return dorevert(); return (FALSE); } int dorevert(void) { int lineno; struct undo_rec *rec; if (access(curbp->b_fname, F_OK|R_OK) != 0) { dobeep(); if (errno == ENOENT) ewprintf("File %s no longer exists!", curbp->b_fname); else ewprintf("File %s is no longer readable!", curbp->b_fname); return (FALSE); } /* Save our current line, so we can go back after reloading. */ lineno = curwp->w_dotline; /* Prevent readin from asking if we want to kill the buffer. */ curbp->b_flag &= ~BFCHG; /* Clean up undo memory */ while ((rec = TAILQ_FIRST(&curbp->b_undo))) { TAILQ_REMOVE(&curbp->b_undo, rec, next); free_undo_record(rec); } if (readin(curbp->b_fname)) return(setlineno(lineno)); return (FALSE); } /* * Diff the current buffer to what is on disk. */ /*ARGSUSED */ int diffbuffer(int f, int n) { struct buffer *bp; struct line *lp, *lpend; size_t len; int ret; char *text, *ttext; char * const argv[] = {DIFFTOOL, "-u", "-p", curbp->b_fname, "-", (char *)NULL}; len = 0; /* C-u is not supported */ if (n > 1) return (ABORT); if (access(DIFFTOOL, X_OK) != 0) { dobeep(); ewprintf("%s not found or not executable.", DIFFTOOL); return (FALSE); } if (curbp->b_fname[0] == 0) { dobeep(); ewprintf("Cannot diff buffer not associated with any files."); return (FALSE); } lpend = curbp->b_headp; for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) { len+=llength(lp); if (lforw(lp) != lpend) /* no implied \n on last line */ len++; } if ((text = calloc(len + 1, sizeof(char))) == NULL) { dobeep(); ewprintf("Cannot allocate memory."); return (FALSE); } ttext = text; for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) { if (llength(lp) != 0) { memcpy(ttext, ltext(lp), llength(lp)); ttext += llength(lp); } if (lforw(lp) != lpend) /* no implied \n on last line */ *ttext++ = '\n'; } bp = bfind("*Diff*", TRUE); bp->b_flag |= BFREADONLY; if (bclear(bp) != TRUE) { free(text); return (FALSE); } ret = pipeio(DIFFTOOL, argv, text, len, bp); if (ret == TRUE) { eerase(); if (lforw(bp->b_headp) == bp->b_headp) addline(bp, "Diff finished (no differences)."); } free(text); return (ret); } /* * Given a file name, either find the buffer it uses, or create a new * empty buffer to put it in. */ struct buffer * findbuffer(char *fn) { struct buffer *bp; char bname[NBUFN], fname[NBUFN]; if (strlcpy(fname, fn, sizeof(fname)) >= sizeof(fname)) { dobeep(); ewprintf("filename too long"); return (NULL); } for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (strcmp(bp->b_fname, fname) == 0) return (bp); } /* Not found. Create a new one, adjusting name first */ if (augbname(bname, fname, sizeof(bname)) == FALSE) return (NULL); bp = bfind(bname, TRUE); return (bp); } mg-20161005/cinfo.c010064400017510001751000000112751276204442100125030ustar00hanboetes/* $OpenBSD: cinfo.c,v 1.18 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Character class tables. * Do it yourself character classification * macros, that understand the multinational character set, * and let me ask some questions the standard macros (in * ctype.h) don't let you ask. */ #include #include #include #include #include "def.h" /* * This table, indexed by a character drawn * from the 256 member character set, is used by my * own character type macros to answer questions about the * type of a character. It handles the full multinational * character set, and lets me ask some questions that the * standard "ctype" macros cannot ask. */ /* * Due to incompatible behaviour between "standard" emacs and * ctags word traversing, '_' character's value is changed on * the fly in ctags mode, hence non-const. */ char cinfo[256] = { _MG_C, _MG_C, _MG_C, _MG_C, /* 0x0X */ _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, /* 0x1X */ _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, _MG_C, 0, _MG_P, 0, 0, /* 0x2X */ _MG_W, _MG_W, 0, _MG_W, 0, 0, 0, 0, 0, 0, _MG_P, 0, _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, /* 0x3X */ _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, _MG_D | _MG_W, 0, 0, 0, 0, 0, _MG_P, 0, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, /* 0x4X */ _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, /* 0x5X */ _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, 0, 0, 0, 0, 0, 0, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, /* 0x6X */ _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, /* 0x7X */ _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, 0, 0, 0, 0, _MG_C, 0, 0, 0, 0, /* 0x8X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x9X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xAX */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xBX */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, /* 0xCX */ _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, 0, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, /* 0xDX */ _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, _MG_U | _MG_W, 0, _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, /* 0xEX */ _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, 0, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, /* 0xFX */ _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, _MG_L | _MG_W, 0, 0 }; /* * Find the name of a keystroke. Needs to be changed to handle 8-bit printing * characters and function keys better. Returns a pointer to the terminating * '\0'. Returns NULL on failure. */ char * getkeyname(char *cp, size_t len, int k) { const char *np; size_t copied; if (k < 0) k = CHARMASK(k); /* sign extended char */ switch (k) { case CCHR('@'): np = "C-SPC"; break; case CCHR('I'): np = "TAB"; break; case CCHR('M'): np = "RET"; break; case CCHR('['): np = "ESC"; break; case ' ': np = "SPC"; break; /* yuck again */ case CCHR('?'): np = "DEL"; break; default: if (k >= KFIRST && k <= KLAST && (np = keystrings[k - KFIRST]) != NULL) break; if (k > CCHR('?')) { *cp++ = '0'; *cp++ = ((k >> 6) & 7) + '0'; *cp++ = ((k >> 3) & 7) + '0'; *cp++ = (k & 7) + '0'; *cp = '\0'; return (cp); } else if (k < ' ') { *cp++ = 'C'; *cp++ = '-'; k = CCHR(k); if (ISUPPER(k)) k = TOLOWER(k); } *cp++ = k; *cp = '\0'; return (cp); } copied = strlcpy(cp, np, len); if (copied >= len) copied = len - 1; return (cp + copied); } mg-20161005/cmode.c010064400017510001751000000245521276204442100124760ustar00hanboetes/* $OpenBSD: cmode.c,v 1.16 2015/09/26 21:51:58 jasper Exp $ */ /* * This file is in the public domain. * * Author: Kjell Wooding */ /* * Implement an non-irritating KNF-compliant mode for editing * C code. */ #include #include #include #include #include "def.h" #include "funmap.h" #include "kbd.h" /* Pull in from modes.c */ extern int changemode(int, int, char *); static int cc_strip_trailp = TRUE; /* Delete Trailing space? */ static int cc_basic_indent = 8; /* Basic Indent multiple */ static int cc_cont_indent = 4; /* Continued line indent */ static int cc_colon_indent = -8; /* Label / case indent */ static int getmatch(int, int); static int getindent(const struct line *, int *); static int in_whitespace(struct line *, int); static int findcolpos(const struct buffer *, const struct line *, int); static struct line *findnonblank(struct line *); static int isnonblank(const struct line *, int); void cmode_init(void); int cc_comment(int, int); /* Keymaps */ static PF cmode_brace[] = { cc_brace, /* } */ }; static PF cmode_cCP[] = { compile, /* C-c P */ }; static PF cmode_cc[] = { NULL, /* ^C */ rescan, /* ^D */ rescan, /* ^E */ rescan, /* ^F */ rescan, /* ^G */ rescan, /* ^H */ cc_tab, /* ^I */ rescan, /* ^J */ rescan, /* ^K */ rescan, /* ^L */ cc_lfindent, /* ^M */ }; static PF cmode_spec[] = { cc_char, /* : */ }; static struct KEYMAPE (1) cmode_cmap = { 1, 1, rescan, { { 'P', 'P', cmode_cCP, NULL } } }; static struct KEYMAPE (3) cmodemap = { 3, 3, rescan, { { CCHR('C'), CCHR('M'), cmode_cc, (KEYMAP *) &cmode_cmap }, { ':', ':', cmode_spec, NULL }, { '}', '}', cmode_brace, NULL } } }; /* Funtion, Mode hooks */ void cmode_init(void) { funmap_add(cmode, "c-mode"); funmap_add(cc_char, "c-handle-special-char"); funmap_add(cc_brace, "c-handle-special-brace"); funmap_add(cc_tab, "c-tab-or-indent"); funmap_add(cc_indent, "c-indent"); funmap_add(cc_lfindent, "c-indent-and-newline"); maps_add((KEYMAP *)&cmodemap, "c"); } /* * Enable/toggle c-mode */ int cmode(int f, int n) { return(changemode(f, n, "c")); } /* * Handle special C character - selfinsert then indent. */ int cc_char(int f, int n) { if (n < 0) return (FALSE); if (selfinsert(FFRAND, n) == FALSE) return (FALSE); return (cc_indent(FFRAND, n)); } /* * Handle special C character - selfinsert then indent. */ int cc_brace(int f, int n) { if (n < 0) return (FALSE); if (showmatch(FFRAND, 1) == FALSE) return (FALSE); return (cc_indent(FFRAND, n)); } /* * If we are in the whitespace at the beginning of the line, * simply act as a regular tab. If we are not, indent * current line according to whitespace rules. */ int cc_tab(int f, int n) { int inwhitep = FALSE; /* In leading whitespace? */ inwhitep = in_whitespace(curwp->w_dotp, llength(curwp->w_dotp)); /* If empty line, or in whitespace */ if (llength(curwp->w_dotp) == 0 || inwhitep) return (selfinsert(f, n)); return (cc_indent(FFRAND, 1)); } /* * Attempt to indent current line according to KNF rules. */ int cc_indent(int f, int n) { int pi, mi; /* Previous indents (mi is ignored) */ int ci; /* current indent */ struct line *lp; int ret; if (n < 0) return (FALSE); undo_boundary_enable(FFRAND, 0); if (cc_strip_trailp) deltrailwhite(FFRAND, 1); /* * Search backwards for a non-blank, non-preprocessor, * non-comment line */ lp = findnonblank(curwp->w_dotp); pi = getindent(lp, &mi); /* Strip leading space on current line */ delleadwhite(FFRAND, 1); /* current indent is computed only to current position */ (void)getindent(curwp->w_dotp, &ci); if (pi + ci < 0) ret = indent(FFOTHARG, 0); else ret = indent(FFOTHARG, pi + ci); undo_boundary_enable(FFRAND, 1); return (ret); } /* * Indent-and-newline (technically, newline then indent) */ int cc_lfindent(int f, int n) { if (n < 0) return (FALSE); if (enewline(FFRAND, 1) == FALSE) return (FALSE); return (cc_indent(FFRAND, n)); } /* * Get the level of indention after line lp is processed * Note getindent has two returns: * curi = value if indenting current line. * return value = value affecting subsequent lines. */ static int getindent(const struct line *lp, int *curi) { int lo, co; /* leading space, current offset*/ int nicol = 0; /* position count */ int c = '\0'; /* current char */ int newind = 0; /* new index value */ int stringp = FALSE; /* in string? */ int escp = FALSE; /* Escape char? */ int lastc = '\0'; /* Last matched string delimeter */ int nparen = 0; /* paren count */ int obrace = 0; /* open brace count */ int cbrace = 0; /* close brace count */ int firstnwsp = FALSE; /* First nonspace encountered? */ int colonp = FALSE; /* Did we see a colon? */ int questionp = FALSE; /* Did we see a question mark? */ int slashp = FALSE; /* Slash? */ int astp = FALSE; /* Asterisk? */ int cpos = -1; /* comment position */ int cppp = FALSE; /* Preprocessor command? */ *curi = 0; /* Compute leading space */ for (lo = 0; lo < llength(lp); lo++) { if (!isspace(c = lgetc(lp, lo))) break; if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif /* NOTAB */ ) { nicol |= 0x07; } nicol++; } /* If last line was blank, choose 0 */ if (lo == llength(lp)) nicol = 0; newind = 0; /* Compute modifiers */ for (co = lo; co < llength(lp); co++) { c = lgetc(lp, co); /* We have a non-whitespace char */ if (!firstnwsp && !isspace(c)) { if (c == '#') cppp = TRUE; firstnwsp = TRUE; } if (c == '\\') escp = !escp; else if (stringp) { if (!escp && (c == '"' || c == '\'')) { /* unescaped string char */ if (getmatch(c, lastc)) stringp = FALSE; } } else if (c == '"' || c == '\'') { stringp = TRUE; lastc = c; } else if (c == '(') { nparen++; } else if (c == ')') { nparen--; } else if (c == '{') { obrace++; firstnwsp = FALSE; } else if (c == '}') { cbrace++; } else if (c == '?') { questionp = TRUE; } else if (c == ':') { /* ignore (foo ? bar : baz) construct */ if (!questionp) colonp = TRUE; } else if (c == '/') { /* first nonwhitespace? -> indent */ if (firstnwsp) { /* If previous char asterisk -> close */ if (astp) cpos = -1; else slashp = TRUE; } } else if (c == '*') { /* If previous char slash -> open */ if (slashp) cpos = co; else astp = TRUE; } else if (firstnwsp) { firstnwsp = FALSE; } /* Reset matches that apply to next character only */ if (c != '\\') escp = FALSE; if (c != '*') astp = FALSE; if (c != '/') slashp = FALSE; } /* * If not terminated with a semicolon, and brace or paren open. * we continue */ if (colonp) { *curi += cc_colon_indent; newind -= cc_colon_indent; } *curi -= (cbrace) * cc_basic_indent; newind += obrace * cc_basic_indent; if (nparen < 0) newind -= cc_cont_indent; else if (nparen > 0) newind += cc_cont_indent; *curi += nicol; /* Ignore preprocessor. Otherwise, add current column */ if (cppp) { newind = nicol; *curi = 0; } else { newind += nicol; } if (cpos != -1) newind = findcolpos(curbp, lp, cpos); return (newind); } /* * Given a delimeter and its purported mate, tell us if they * match. */ static int getmatch(int c, int mc) { int match = FALSE; switch (c) { case '"': match = (mc == '"'); break; case '\'': match = (mc == '\''); break; case '(': match = (mc == ')'); break; case '[': match = (mc == ']'); break; case '{': match = (mc == '}'); break; } return (match); } static int in_whitespace(struct line *lp, int len) { int lo; int inwhitep = FALSE; for (lo = 0; lo < len; lo++) { if (!isspace(lgetc(lp, lo))) break; if (lo == len - 1) inwhitep = TRUE; } return (inwhitep); } /* convert a line/offset pair to a column position (for indenting) */ static int findcolpos(const struct buffer *bp, const struct line *lp, int lo) { int col, i, c; char tmp[5]; /* determine column */ col = 0; for (i = 0; i < lo; ++i) { c = lgetc(lp, i); if (c == '\t' #ifdef NOTAB && !(bp->b_flag & BFNOTAB) #endif /* NOTAB */ ) { col |= 0x07; col++; } else if (ISCTRL(c) != FALSE) col += 2; else if (isprint(c)) { col++; } else { col += snprintf(tmp, sizeof(tmp), "\\%o", c); } } return (col); } /* * Find a non-blank line, searching backwards from the supplied line pointer. * For C, nonblank is non-preprocessor, non C++, and accounts * for complete C-style comments. */ static struct line * findnonblank(struct line *lp) { int lo; int nonblankp = FALSE; int commentp = FALSE; int slashp; int astp; int c; while (lback(lp) != curbp->b_headp && (commentp || !nonblankp)) { lp = lback(lp); slashp = FALSE; astp = FALSE; /* Potential nonblank? */ nonblankp = isnonblank(lp, llength(lp)); /* * Search from end, removing complete C-style * comments. If one is found, ignore it and * test for nonblankness from where it starts. */ for (lo = llength(lp) - 1; lo >= 0; lo--) { if (!isspace(c = lgetc(lp, lo))) { if (commentp) { /* find comment "open" */ if (c == '*') astp = TRUE; else if (astp && c == '/') { commentp = FALSE; /* whitespace to here? */ nonblankp = isnonblank(lp, lo); } } else { /* find comment "close" */ if (c == '/') slashp = TRUE; else if (slashp && c == '*') /* found a comment */ commentp = TRUE; } } } } /* Rewound to start of file? */ if (lback(lp) == curbp->b_headp && !nonblankp) return (curbp->b_headp); return (lp); } /* * Given a line, scan forward to 'omax' and determine if we * are all C whitespace. * Note that preprocessor directives and C++-style comments * count as whitespace. C-style comments do not, and must * be handled elsewhere. */ static int isnonblank(const struct line *lp, int omax) { int nonblankp = FALSE; /* Return value */ int slashp = FALSE; /* Encountered slash */ int lo; /* Loop index */ int c; /* char being read */ /* Scan from front for preprocessor, C++ comments */ for (lo = 0; lo < omax; lo++) { if (!isspace(c = lgetc(lp, lo))) { /* Possible nonblank line */ nonblankp = TRUE; /* skip // and # starts */ if (c == '#' || (slashp && c == '/')) { nonblankp = FALSE; break; } else if (!slashp && c == '/') { slashp = TRUE; continue; } } slashp = FALSE; } return (nonblankp); } mg-20161005/cscope.c010064400017510001751000000307131276204442100126570ustar00hanboetes/* $OpenBSD: cscope.c,v 1.16 2016/01/19 14:51:00 sunil Exp $ */ /* * This file is in the public domain. * * Author: Sunil Nimmagadda */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "def.h" #define CSSYMBOL 0 #define CSDEFINITION 1 #define CSCALLEDFUNCS 2 #define CSCALLERFUNCS 3 #define CSTEXT 4 #define CSEGREP 6 #define CSFINDFILE 7 #define CSINCLUDES 8 struct cstokens { const char *fname; const char *function; const char *lineno; const char *pattern; }; struct csmatch { TAILQ_ENTRY(csmatch) entry; int lineno; }; struct csrecord { TAILQ_ENTRY(csrecord) entry; char *filename; TAILQ_HEAD(matches, csmatch) matches; }; static TAILQ_HEAD(csrecords, csrecord) csrecords = TAILQ_HEAD_INITIALIZER(csrecords); static struct csrecord *addentryr; static struct csrecord *currecord; static struct csmatch *curmatch; static const char *addentryfn; static const char *csprompt[] = { "Find this symbol: ", "Find this global definition: ", "Find functions called by this function: ", "Find functions calling this function: ", "Find this text string: ", "Change this text string: ", "Find this egrep pattern: ", "Find this file: ", "Find files #including this file: " }; static int addentry(struct buffer *, char *); static void csflush(void); static int do_cscope(int); static int csexists(const char *); static int getattr(char *, struct cstokens *); static int jumptomatch(void); static void prettyprint(struct buffer *, struct cstokens *); static const char *ltrim(const char *); /* * Find this symbol. Bound to C-c s s */ /* ARGSUSED */ int cssymbol(int f, int n) { return (do_cscope(CSSYMBOL)); } /* * Find this global definition. Bound to C-c s d */ /* ARGSUSED */int csdefinition(int f, int n) { return (do_cscope(CSDEFINITION)); } /* * Find functions called by this function. Bound to C-c s l */ /* ARGSUSED */ int csfuncalled(int f, int n) { return (do_cscope(CSCALLEDFUNCS)); } /* * Find functions calling this function. Bound to C-c s c */ /* ARGSUSED */ int cscallerfuncs(int f, int n) { return (do_cscope(CSCALLERFUNCS)); } /* * Find this text. Bound to C-c s t */ /* ARGSUSED */ int csfindtext(int f, int n) { return (do_cscope(CSTEXT)); } /* * Find this egrep pattern. Bound to C-c s e */ /* ARGSUSED */ int csegrep(int f, int n) { return (do_cscope(CSEGREP)); } /* * Find this file. Bound to C-c s f */ /* ARGSUSED */ int csfindfile(int f, int n) { return (do_cscope(CSFINDFILE)); } /* * Find files #including this file. Bound to C-c s i */ /* ARGSUSED */ int csfindinc(int f, int n) { return (do_cscope(CSINCLUDES)); } /* * Create list of files to index in the given directory * using cscope-indexer. */ /* ARGSUSED */ int cscreatelist(int f, int n) { struct buffer *bp; struct stat sb; FILE *fpipe; char dir[NFILEN], cmd[BUFSIZ], title[BUFSIZ], *line, *bufp; size_t len; int clen; if (getbufcwd(dir, sizeof(dir)) == FALSE) dir[0] = '\0'; bufp = eread("Index files in directory: ", dir, sizeof(dir), EFCR | EFDEF | EFNEW | EFNUL); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if (stat(dir, &sb) == -1) { dobeep(); ewprintf("stat: %s", strerror(errno)); return (FALSE); } else if (S_ISDIR(sb.st_mode) == 0) { dobeep(); ewprintf("%s: Not a directory", dir); return (FALSE); } if (csexists("cscope-indexer") == FALSE) { dobeep(); ewprintf("no such file or directory, cscope-indexer"); return (FALSE); } clen = snprintf(cmd, sizeof(cmd), "cscope-indexer -v %s", dir); if (clen < 0 || clen >= sizeof(cmd)) return (FALSE); if ((fpipe = popen(cmd, "r")) == NULL) { dobeep(); ewprintf("problem opening pipe"); return (FALSE); } bp = bfind("*cscope*", TRUE); if (bclear(bp) != TRUE) { pclose(fpipe); return (FALSE); } bp->b_flag |= BFREADONLY; clen = snprintf(title, sizeof(title), "%s%s", "Creating cscope file list 'cscope.files' in: ", dir); if (clen < 0 || clen >= sizeof(title)) { pclose(fpipe); return (FALSE); } addline(bp, title); addline(bp, ""); /* All lines are NUL terminated */ while ((line = fgetln(fpipe, &len)) != NULL) { line[len - 1] = '\0'; addline(bp, line); } pclose(fpipe); return (popbuftop(bp, WNONE)); } /* * Next Symbol. Bound to C-c s n */ /* ARGSUSED */ int csnextmatch(int f, int n) { struct csrecord *r; struct csmatch *m; if (curmatch == NULL) { if ((r = TAILQ_FIRST(&csrecords)) == NULL) { dobeep(); ewprintf("The *cscope* buffer does not exist yet"); return (FALSE); } currecord = r; curmatch = TAILQ_FIRST(&r->matches); } else { m = TAILQ_NEXT(curmatch, entry); if (m == NULL) { r = TAILQ_NEXT(currecord, entry); if (r == NULL) { dobeep(); ewprintf("The end of *cscope* buffer has been" " reached"); return (FALSE); } else { currecord = r; curmatch = TAILQ_FIRST(&currecord->matches); } } else curmatch = m; } return (jumptomatch()); } /* * Previous Symbol. Bound to C-c s p */ /* ARGSUSED */ int csprevmatch(int f, int n) { struct csmatch *m; struct csrecord *r; if (curmatch == NULL) return (FALSE); else { m = TAILQ_PREV(curmatch, matches, entry); if (m) curmatch = m; else { r = TAILQ_PREV(currecord, csrecords, entry); if (r == NULL) { dobeep(); ewprintf("The beginning of *cscope* buffer has" " been reached"); return (FALSE); } else { currecord = r; curmatch = TAILQ_LAST(&currecord->matches, matches); } } } return (jumptomatch()); } /* * Next file. */ int csnextfile(int f, int n) { struct csrecord *r; if (curmatch == NULL) { if ((r = TAILQ_FIRST(&csrecords)) == NULL) { dobeep(); ewprintf("The *cscope* buffer does not exist yet"); return (FALSE); } } else { if ((r = TAILQ_NEXT(currecord, entry)) == NULL) { dobeep(); ewprintf("The end of *cscope* buffer has been reached"); return (FALSE); } } currecord = r; curmatch = TAILQ_FIRST(&currecord->matches); return (jumptomatch()); } /* * Previous file. */ int csprevfile(int f, int n) { struct csrecord *r; if (curmatch == NULL) { if ((r = TAILQ_FIRST(&csrecords)) == NULL) { dobeep(); ewprintf("The *cscope* buffer does not exist yet"); return (FALSE); } } else { if ((r = TAILQ_PREV(currecord, csrecords, entry)) == NULL) { dobeep(); ewprintf("The beginning of *cscope* buffer has been" " reached"); return (FALSE); } } currecord = r; curmatch = TAILQ_FIRST(&currecord->matches); return (jumptomatch()); } /* * The current symbol location is extracted from currecord->filename and * curmatch->lineno. Load the file similar to filevisit and goto the * lineno recorded. */ int jumptomatch(void) { struct buffer *bp; char *adjf; if (curmatch == NULL || currecord == NULL) return (FALSE); adjf = adjustname(currecord->filename, TRUE); if (adjf == NULL) return (FALSE); if ((bp = findbuffer(adjf)) == NULL) return (FALSE); curbp = bp; if (showbuffer(bp, curwp, WFFULL) != TRUE) return (FALSE); if (bp->b_fname[0] == '\0') { if (readin(adjf) != TRUE) killbuffer(bp); } gotoline(FFARG, curmatch->lineno); return (TRUE); } /* * Ask for the symbol, construct cscope commandline with the symbol * and passed in index. Popen cscope, read the output into *cscope* * buffer and pop it. */ int do_cscope(int i) { struct buffer *bp; FILE *fpipe; char pattern[MAX_TOKEN], cmd[BUFSIZ], title[BUFSIZ]; char *p, *buf; int clen, nores = 0; size_t len; /* If current buffer isn't a source file just return */ if (fnmatch("*.[chy]", curbp->b_fname, 0) != 0) { dobeep(); ewprintf("C-c s not defined"); return (FALSE); } if (curtoken(0, 1, pattern) == FALSE) return (FALSE); p = eread("%s", pattern, MAX_TOKEN, EFNEW | EFCR | EFDEF, csprompt[i]); if (p == NULL) return (ABORT); else if (p[0] == '\0') return (FALSE); if (csexists("cscope") == FALSE) { dobeep(); ewprintf("no such file or directory, cscope"); return (FALSE); } csflush(); clen = snprintf(cmd, sizeof(cmd), "cscope -L -%d %s 2>/dev/null", i, pattern); if (clen < 0 || clen >= sizeof(cmd)) return (FALSE); if ((fpipe = popen(cmd, "r")) == NULL) { dobeep(); ewprintf("problem opening pipe"); return (FALSE); } bp = bfind("*cscope*", TRUE); if (bclear(bp) != TRUE) { pclose(fpipe); return (FALSE); } bp->b_flag |= BFREADONLY; clen = snprintf(title, sizeof(title), "%s%s", csprompt[i], pattern); if (clen < 0 || clen >= sizeof(title)) { pclose(fpipe); return (FALSE); } addline(bp, title); addline(bp, ""); addline(bp, "-------------------------------------------------------------------------------"); /* All lines are NUL terminated */ while ((buf = fgetln(fpipe, &len)) != NULL) { buf[len - 1] = '\0'; if (addentry(bp, buf) != TRUE) return (FALSE); nores = 1; }; pclose(fpipe); addline(bp, "-------------------------------------------------------------------------------"); if (nores == 0) ewprintf("No matches were found."); return (popbuftop(bp, WNONE)); } /* * For each line read from cscope output, extract the tokens, * add them to list and pretty print a line in *cscope* buffer. */ int addentry(struct buffer *bp, char *csline) { struct csrecord *r; struct csmatch *m; struct cstokens t; int lineno; char buf[BUFSIZ]; const char *errstr; r = NULL; if (getattr(csline, &t) == FALSE) return (FALSE); lineno = strtonum(t.lineno, INT_MIN, INT_MAX, &errstr); if (errstr) return (FALSE); if (addentryfn == NULL || strcmp(addentryfn, t.fname) != 0) { if ((r = malloc(sizeof(struct csrecord))) == NULL) return (FALSE); addentryr = r; if ((r->filename = strndup(t.fname, NFILEN)) == NULL) goto cleanup; addentryfn = r->filename; TAILQ_INIT(&r->matches); if ((m = malloc(sizeof(struct csmatch))) == NULL) goto cleanup; m->lineno = lineno; TAILQ_INSERT_TAIL(&r->matches, m, entry); TAILQ_INSERT_TAIL(&csrecords, r, entry); addline(bp, ""); if (snprintf(buf, sizeof(buf), "*** %s", t.fname) < 0) goto cleanup; addline(bp, buf); } else { if ((m = malloc(sizeof(struct csmatch))) == NULL) goto cleanup; m->lineno = lineno; TAILQ_INSERT_TAIL(&addentryr->matches, m, entry); } prettyprint(bp, &t); return (TRUE); cleanup: free(r); return (FALSE); } /* * Cscope line: */ int getattr(char *line, struct cstokens *t) { char *p; if ((p = strchr(line, ' ')) == NULL) return (FALSE); *p++ = '\0'; t->fname = line; line = p; if ((p = strchr(line, ' ')) == NULL) return (FALSE); *p++ = '\0'; t->function = line; line = p; if ((p = strchr(line, ' ')) == NULL) return (FALSE); *p++ = '\0'; t->lineno = line; if (*p == '\0') return (FALSE); t->pattern = p; return (TRUE); } void prettyprint(struct buffer *bp, struct cstokens *t) { char buf[BUFSIZ]; if (snprintf(buf, sizeof(buf), "%s[%s]\t\t%s", t->function, t->lineno, ltrim(t->pattern)) < 0) return; addline(bp, buf); } const char * ltrim(const char *s) { while (isblank((unsigned char)*s)) s++; return s; } void csflush(void) { struct csrecord *r; struct csmatch *m; while ((r = TAILQ_FIRST(&csrecords)) != NULL) { free(r->filename); while ((m = TAILQ_FIRST(&r->matches)) != NULL) { TAILQ_REMOVE(&r->matches, m, entry); free(m); } TAILQ_REMOVE(&csrecords, r, entry); free(r); } addentryr = NULL; addentryfn = NULL; currecord = NULL; curmatch = NULL; } /* * Check if the cmd exists in $PATH. Split on ":" and iterate through * all paths in $PATH. */ int csexists(const char *cmd) { char fname[NFILEN], *dir, *path, *pathc, *tmp; int len, dlen; /* Special case if prog contains '/' */ if (strchr(cmd, '/')) { if (access(cmd, F_OK) == -1) return (FALSE); else return (TRUE); } if ((tmp = getenv("PATH")) == NULL) return (FALSE); if ((pathc = path = strndup(tmp, NFILEN)) == NULL) { dobeep(); ewprintf("out of memory"); return (FALSE); } while ((dir = strsep(&path, ":")) != NULL) { if (*dir == '\0') continue; dlen = strlen(dir); while (dlen > 0 && dir[dlen-1] == '/') dir[--dlen] = '\0'; /* strip trailing '/' */ len = snprintf(fname, sizeof(fname), "%s/%s", dir, cmd); if (len == -1 || len >= sizeof(fname)) { dobeep(); ewprintf("path too long"); goto cleanup; } if(access(fname, F_OK) == 0) { free(pathc); return (TRUE); } } cleanup: free(pathc); return (FALSE); } mg-20161005/dir.c010064400017510001751000000066321277516274500122020ustar00hanboetes/* $OpenBSD: dir.c,v 1.29 2016/09/12 18:32:54 millert Exp $ */ /* This file is in the public domain. */ /* * Name: MG 2a * Directory management functions * Created: Ron Flax (ron@vsedev.vse.com) * Modified for MG 2a by Mic Kaczmarczik 03-Aug-1987 */ #include #include #include #include #include #include #include "def.h" static char mgcwd[NFILEN]; /* * Initialize anything the directory management routines need. */ void dirinit(void) { mgcwd[0] = '\0'; if (getcwd(mgcwd, sizeof(mgcwd)) == NULL) ewprintf("Can't get current directory!"); if (mgcwd[0] != '\0' && !(mgcwd[0] == '/' && mgcwd[1] == '\0')) (void)strlcat(mgcwd, "/", sizeof(mgcwd)); } /* * Change current working directory. */ /* ARGSUSED */ int changedir(int f, int n) { char bufc[NFILEN], *bufp; (void)strlcpy(bufc, mgcwd, sizeof(bufc)); if ((bufp = eread("Change default directory: ", bufc, NFILEN, EFDEF | EFNEW | EFCR | EFFILE)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); /* Append trailing slash */ if (chdir(bufc) == -1) { dobeep(); ewprintf("Can't change dir to %s", bufc); return (FALSE); } if ((bufp = getcwd(mgcwd, sizeof(mgcwd))) == NULL) { if (bufc[0] == '/') (void)strlcpy(mgcwd, bufc, sizeof(mgcwd)); else (void)strlcat(mgcwd, bufc, sizeof(mgcwd)); } if (mgcwd[strlen(mgcwd) - 1] != '/') (void)strlcat(mgcwd, "/", sizeof(mgcwd)); ewprintf("Current directory is now %s", mgcwd); return (TRUE); } /* * Show current directory. */ /* ARGSUSED */ int showcwdir(int f, int n) { ewprintf("Current directory: %s", mgcwd); return (TRUE); } int getcwdir(char *buf, size_t len) { if (strlcpy(buf, mgcwd, len) >= len) return (FALSE); return (TRUE); } /* Create the directory and it's parents. */ /* ARGSUSED */ int makedir(int f, int n) { return (ask_makedir()); } int ask_makedir(void) { char bufc[NFILEN]; char *path; if (getbufcwd(bufc, sizeof(bufc)) != TRUE) return (ABORT); if ((path = eread("Make directory: ", bufc, NFILEN, EFDEF | EFNEW | EFCR | EFFILE)) == NULL) return (ABORT); else if (path[0] == '\0') return (FALSE); return (do_makedir(path)); } int do_makedir(char *path) { struct stat sb; int finished, ishere; mode_t dir_mode, mode, oumask; char *slash; if ((path = adjustname(path, TRUE)) == NULL) return (FALSE); /* Remove trailing slashes */ slash = strrchr(path, '\0'); while (--slash > path && *slash == '/') *slash = '\0'; slash = path; oumask = umask(0); mode = 0777 & ~oumask; dir_mode = mode | S_IWUSR | S_IXUSR; for (;;) { slash += strspn(slash, "/"); slash += strcspn(slash, "/"); finished = (*slash == '\0'); *slash = '\0'; ishere = !stat(path, &sb); if (finished && ishere) { dobeep(); ewprintf("Cannot create directory %s: file exists", path); return(FALSE); } else if (!finished && ishere && S_ISDIR(sb.st_mode)) { *slash = '/'; continue; } if (mkdir(path, finished ? mode : dir_mode) == 0) { if (mode > 0777 && chmod(path, mode) < 0) { umask(oumask); return (ABORT); } } else { if (!ishere || !S_ISDIR(sb.st_mode)) { if (!ishere) { dobeep(); ewprintf("Creating directory: " "permission denied, %s", path); } else eerase(); umask(oumask); return (FALSE); } } if (finished) break; *slash = '/'; } eerase(); umask(oumask); return (TRUE); } mg-20161005/dired.c010064400017510001751000000540231276204442100124720ustar00hanboetes/* $OpenBSD: dired.c,v 1.82 2016/01/02 10:39:19 lum Exp $ */ /* This file is in the public domain. */ /* dired module for mg 2a * by Robert A. Larson */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "def.h" #include "funmap.h" #include "kbd.h" void dired_init(void); static int dired(int, int); static int d_otherwindow(int, int); static int d_undel(int, int); static int d_undelbak(int, int); static int d_findfile(int, int); static int d_ffotherwindow(int, int); static int d_expunge(int, int); static int d_copy(int, int); static int d_del(int, int); static int d_rename(int, int); static int d_exec(int, struct buffer *, const char *, const char *, ...); static int d_shell_command(int, int); static int d_create_directory(int, int); static int d_makename(struct line *, char *, size_t); static int d_warpdot(struct line *, int *); static int d_forwpage(int, int); static int d_backpage(int, int); static int d_forwline(int, int); static int d_backline(int, int); static int d_killbuffer_cmd(int, int); static int d_refreshbuffer(int, int); static int d_filevisitalt(int, int); static void reaper(int); static struct buffer *refreshbuffer(struct buffer *); static int createlist(struct buffer *); static void redelete(struct buffer *); static char *findfname(struct line *, char *); extern struct keymap_s helpmap, cXmap, metamap; const char DDELCHAR = 'D'; /* * Structure which holds a linked list of file names marked for * deletion. Used to maintain dired buffer 'state' between refreshes. */ struct delentry { SLIST_ENTRY(delentry) entry; char *fn; }; SLIST_HEAD(slisthead, delentry) delhead = SLIST_HEAD_INITIALIZER(delhead); static PF dirednul[] = { setmark, /* ^@ */ gotobol, /* ^A */ backchar, /* ^B */ rescan, /* ^C */ d_del, /* ^D */ gotoeol, /* ^E */ forwchar, /* ^F */ ctrlg, /* ^G */ NULL, /* ^H */ }; static PF diredcl[] = { reposition, /* ^L */ d_findfile, /* ^M */ d_forwline, /* ^N */ rescan, /* ^O */ d_backline, /* ^P */ rescan, /* ^Q */ backisearch, /* ^R */ forwisearch, /* ^S */ rescan, /* ^T */ universal_argument, /* ^U */ d_forwpage, /* ^V */ rescan, /* ^W */ NULL /* ^X */ }; static PF diredcz[] = { spawncli, /* ^Z */ NULL, /* esc */ rescan, /* ^\ */ rescan, /* ^] */ rescan, /* ^^ */ rescan, /* ^_ */ d_forwline, /* SP */ d_shell_command, /* ! */ rescan, /* " */ rescan, /* # */ rescan, /* $ */ rescan, /* % */ rescan, /* & */ rescan, /* ' */ rescan, /* ( */ rescan, /* ) */ rescan, /* * */ d_create_directory /* + */ }; static PF direda[] = { d_filevisitalt, /* a */ rescan, /* b */ d_copy, /* c */ d_del, /* d */ d_findfile, /* e */ d_findfile, /* f */ d_refreshbuffer /* g */ }; static PF diredn[] = { d_forwline, /* n */ d_ffotherwindow, /* o */ d_backline, /* p */ d_killbuffer_cmd, /* q */ d_rename, /* r */ rescan, /* s */ rescan, /* t */ d_undel, /* u */ rescan, /* v */ rescan, /* w */ d_expunge /* x */ }; static PF direddl[] = { d_undelbak /* del */ }; static PF diredbp[] = { d_backpage /* v */ }; static PF dirednull[] = { NULL }; static struct KEYMAPE (1) d_backpagemap = { 1, 1, rescan, { { 'v', 'v', diredbp, NULL } } }; static struct KEYMAPE (7) diredmap = { 7, 7, rescan, { { CCHR('@'), CCHR('H'), dirednul, (KEYMAP *) & helpmap }, { CCHR('L'), CCHR('X'), diredcl, (KEYMAP *) & cXmap }, { CCHR('['), CCHR('['), dirednull, (KEYMAP *) & d_backpagemap }, { CCHR('Z'), '+', diredcz, (KEYMAP *) & metamap }, { 'a', 'g', direda, NULL }, { 'n', 'x', diredn, NULL }, { CCHR('?'), CCHR('?'), direddl, NULL }, } }; void dired_init(void) { funmap_add(dired, "dired"); funmap_add(d_undelbak, "dired-unmark-backward"); funmap_add(d_create_directory, "dired-create-directory"); funmap_add(d_copy, "dired-do-copy"); funmap_add(d_expunge, "dired-do-flagged-delete"); funmap_add(d_findfile, "dired-find-file"); funmap_add(d_ffotherwindow, "dired-find-file-other-window"); funmap_add(d_del, "dired-flag-file-deletion"); funmap_add(d_forwline, "dired-next-line"); funmap_add(d_otherwindow, "dired-other-window"); funmap_add(d_backline, "dired-previous-line"); funmap_add(d_rename, "dired-do-rename"); funmap_add(d_backpage, "dired-scroll-down"); funmap_add(d_forwpage, "dired-scroll-up"); funmap_add(d_undel, "dired-unmark"); funmap_add(d_killbuffer_cmd, "quit-window"); maps_add((KEYMAP *)&diredmap, "dired"); dobindkey(fundamental_map, "dired", "^Xd"); } /* ARGSUSED */ int dired(int f, int n) { char dname[NFILEN], *bufp, *slash; struct buffer *bp; if (curbp->b_fname[0] != '\0') { (void)strlcpy(dname, curbp->b_fname, sizeof(dname)); if ((slash = strrchr(dname, '/')) != NULL) { *(slash + 1) = '\0'; } } else { if (getcwd(dname, sizeof(dname)) == NULL) dname[0] = '\0'; } if ((bufp = eread("Dired: ", dname, NFILEN, EFDEF | EFNEW | EFCR)) == NULL) return (ABORT); if (bufp[0] == '\0') return (FALSE); if ((bp = dired_(bufp)) == NULL) return (FALSE); curbp = bp; return (showbuffer(bp, curwp, WFFULL | WFMODE)); } /* ARGSUSED */ int d_otherwindow(int f, int n) { char dname[NFILEN], *bufp, *slash; struct buffer *bp; struct mgwin *wp; if (curbp->b_fname[0] != '\0') { (void)strlcpy(dname, curbp->b_fname, sizeof(dname)); if ((slash = strrchr(dname, '/')) != NULL) { *(slash + 1) = '\0'; } } else { if (getcwd(dname, sizeof(dname)) == NULL) dname[0] = '\0'; } if ((bufp = eread("Dired other window: ", dname, NFILEN, EFDEF | EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if ((bp = dired_(bufp)) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; curwp = wp; return (TRUE); } /* ARGSUSED */ int d_del(int f, int n) { if (n < 0) return (FALSE); while (n--) { if (d_warpdot(curwp->w_dotp, &curwp->w_doto) == TRUE) { lputc(curwp->w_dotp, 0, DDELCHAR); curbp->b_flag |= BFDIREDDEL; } if (lforw(curwp->w_dotp) != curbp->b_headp) { curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_dotline++; } } curwp->w_rflag |= WFEDIT | WFMOVE; return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } /* ARGSUSED */ int d_undel(int f, int n) { if (n < 0) return (d_undelbak(f, -n)); while (n--) { if (llength(curwp->w_dotp) > 0) lputc(curwp->w_dotp, 0, ' '); if (lforw(curwp->w_dotp) != curbp->b_headp) { curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_dotline++; } } curwp->w_rflag |= WFEDIT | WFMOVE; return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } /* ARGSUSED */ int d_undelbak(int f, int n) { if (n < 0) return (d_undel(f, -n)); while (n--) { if (lback(curwp->w_dotp) != curbp->b_headp) { curwp->w_dotp = lback(curwp->w_dotp); curwp->w_dotline--; } if (llength(curwp->w_dotp) > 0) lputc(curwp->w_dotp, 0, ' '); } curwp->w_rflag |= WFEDIT | WFMOVE; return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } /* ARGSUSED */ int d_findfile(int f, int n) { struct buffer *bp; int s; char fname[NFILEN]; if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT) return (FALSE); if (s == TRUE) bp = dired_(fname); else bp = findbuffer(fname); if (bp == NULL) return (FALSE); curbp = bp; if (showbuffer(bp, curwp, WFFULL) != TRUE) return (FALSE); if (bp->b_fname[0] != 0) return (TRUE); return (readin(fname)); } /* ARGSUSED */ int d_ffotherwindow(int f, int n) { char fname[NFILEN]; int s; struct buffer *bp; struct mgwin *wp; if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT) return (FALSE); if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; curwp = wp; if (bp->b_fname[0] != 0) return (TRUE); /* never true for dired buffers */ return (readin(fname)); } /* ARGSUSED */ int d_expunge(int f, int n) { struct line *lp, *nlp; char fname[NFILEN], sname[NFILEN]; int tmp; tmp = curwp->w_dotline; curwp->w_dotline = 0; for (lp = bfirstlp(curbp); lp != curbp->b_headp; lp = nlp) { curwp->w_dotline++; nlp = lforw(lp); if (llength(lp) && lgetc(lp, 0) == 'D') { switch (d_makename(lp, fname, sizeof(fname))) { case ABORT: dobeep(); ewprintf("Bad line in dired buffer"); curwp->w_dotline = tmp; return (FALSE); case FALSE: if (unlink(fname) < 0) { (void)xbasename(sname, fname, NFILEN); dobeep(); ewprintf("Could not delete '%s'", sname); curwp->w_dotline = tmp; return (FALSE); } break; case TRUE: if (rmdir(fname) < 0) { (void)xbasename(sname, fname, NFILEN); dobeep(); ewprintf("Could not delete directory " "'%s'", sname); curwp->w_dotline = tmp; return (FALSE); } break; } lfree(lp); curwp->w_bufp->b_lines--; if (tmp > curwp->w_dotline) tmp--; curwp->w_rflag |= WFFULL; } } curwp->w_dotline = tmp; d_warpdot(curwp->w_dotp, &curwp->w_doto); /* we have deleted all items successfully, remove del flag */ curbp->b_flag &= ~BFDIREDDEL; return (TRUE); } /* ARGSUSED */ int d_copy(int f, int n) { char frname[NFILEN], toname[NFILEN], sname[NFILEN]; char *topath, *bufp; int ret; size_t off; struct buffer *bp; if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) { dobeep(); ewprintf("Not a file"); return (FALSE); } off = strlcpy(toname, curbp->b_fname, sizeof(toname)); if (off >= sizeof(toname) - 1) { /* can't happen, really */ dobeep(); ewprintf("Directory name too long"); return (FALSE); } (void)xbasename(sname, frname, NFILEN); bufp = eread("Copy %s to: ", toname, sizeof(toname), EFDEF | EFNEW | EFCR, sname); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); topath = adjustname(toname, TRUE); ret = (copy(frname, topath) >= 0) ? TRUE : FALSE; if (ret != TRUE) return (ret); if ((bp = refreshbuffer(curbp)) == NULL) return (FALSE); return (showbuffer(bp, curwp, WFFULL | WFMODE)); } /* ARGSUSED */ int d_rename(int f, int n) { char frname[NFILEN], toname[NFILEN]; char *topath, *bufp; int ret; size_t off; struct buffer *bp; char sname[NFILEN]; if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) { dobeep(); ewprintf("Not a file"); return (FALSE); } off = strlcpy(toname, curbp->b_fname, sizeof(toname)); if (off >= sizeof(toname) - 1) { /* can't happen, really */ dobeep(); ewprintf("Directory name too long"); return (FALSE); } (void)xbasename(sname, frname, NFILEN); bufp = eread("Rename %s to: ", toname, sizeof(toname), EFDEF | EFNEW | EFCR, sname); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); topath = adjustname(toname, TRUE); ret = (rename(frname, topath) >= 0) ? TRUE : FALSE; if (ret != TRUE) return (ret); if ((bp = refreshbuffer(curbp)) == NULL) return (FALSE); return (showbuffer(bp, curwp, WFFULL | WFMODE)); } /* ARGSUSED */ void reaper(int signo __attribute__((unused))) { int save_errno = errno, status; while (waitpid(-1, &status, WNOHANG) >= 0) ; errno = save_errno; } /* * Pipe the currently selected file through a shell command. */ /* ARGSUSED */ int d_shell_command(int f, int n) { char command[512], fname[PATH_MAX], *bufp; struct buffer *bp; struct mgwin *wp; char sname[NFILEN]; bp = bfind("*Shell Command Output*", TRUE); if (bclear(bp) != TRUE) return (ABORT); if (d_makename(curwp->w_dotp, fname, sizeof(fname)) != FALSE) { dobeep(); ewprintf("bad line"); return (ABORT); } command[0] = '\0'; (void)xbasename(sname, fname, NFILEN); bufp = eread("! on %s: ", command, sizeof(command), EFNEW, sname); if (bufp == NULL) return (ABORT); if (d_exec(0, bp, fname, "sh", "-c", command, NULL) != TRUE) return (ABORT); if ((wp = popbuf(bp, WNONE)) == NULL) return (ABORT); /* XXX - free the buffer?? */ curwp = wp; curbp = wp->w_bufp; return (TRUE); } /* * Pipe input file to cmd and insert the command's output in the * given buffer. Each line will be prefixed with the given * number of spaces. */ static int d_exec(int space, struct buffer *bp, const char *input, const char *cmd, ...) { char buf[BUFSIZ]; va_list ap; struct sigaction olda, newa; char **argv = NULL, *cp; FILE *fin; int fds[2] = { -1, -1 }; int infd = -1; int ret = (ABORT), n; pid_t pid; if (sigaction(SIGCHLD, NULL, &olda) == -1) return (ABORT); /* Find the number of arguments. */ va_start(ap, cmd); for (n = 2; va_arg(ap, char *) != NULL; n++) ; va_end(ap); /* Allocate and build the argv. */ if ((argv = calloc(n, sizeof(*argv))) == NULL) { dobeep(); ewprintf("Can't allocate argv : %s", strerror(errno)); goto out; } n = 1; argv[0] = (char *)cmd; va_start(ap, cmd); while ((argv[n] = va_arg(ap, char *)) != NULL) n++; va_end(ap); if (input == NULL) input = "/dev/null"; if ((infd = open(input, O_RDONLY)) == -1) { dobeep(); ewprintf("Can't open input file : %s", strerror(errno)); goto out; } if (pipe(fds) == -1) { dobeep(); ewprintf("Can't create pipe : %s", strerror(errno)); goto out; } newa.sa_handler = reaper; newa.sa_flags = 0; if (sigaction(SIGCHLD, &newa, NULL) == -1) goto out; if ((pid = fork()) == -1) { dobeep(); ewprintf("Can't fork"); goto out; } switch (pid) { case 0: /* Child */ close(fds[0]); dup2(infd, STDIN_FILENO); dup2(fds[1], STDOUT_FILENO); dup2(fds[1], STDERR_FILENO); if (execvp(argv[0], argv) == -1) ewprintf("Can't exec %s: %s", argv[0], strerror(errno)); exit(1); break; default: /* Parent */ close(infd); close(fds[1]); infd = fds[1] = -1; if ((fin = fdopen(fds[0], "r")) == NULL) goto out; while (fgets(buf, sizeof(buf), fin) != NULL) { cp = strrchr(buf, '\n'); if (cp == NULL && !feof(fin)) { /* too long a line */ int c; addlinef(bp, "%*s%s...", space, "", buf); while ((c = getc(fin)) != EOF && c != '\n') ; continue; } else if (cp) *cp = '\0'; addlinef(bp, "%*s%s", space, "", buf); } fclose(fin); break; } ret = (TRUE); out: if (sigaction(SIGCHLD, &olda, NULL) == -1) ewprintf("Warning, couldn't reset previous signal handler"); if (fds[0] != -1) close(fds[0]); if (fds[1] != -1) close(fds[1]); if (infd != -1) close(infd); free(argv); return ret; } /* ARGSUSED */ int d_create_directory(int f, int n) { int ret; struct buffer *bp; ret = ask_makedir(); if (ret != TRUE) return(ret); if ((bp = refreshbuffer(curbp)) == NULL) return (FALSE); return (showbuffer(bp, curwp, WFFULL | WFMODE)); } /* ARGSUSED */ int d_killbuffer_cmd(int f, int n) { return(killbuffer_cmd(FFRAND, 0)); } int d_refreshbuffer(int f, int n) { struct buffer *bp; if ((bp = refreshbuffer(curbp)) == NULL) return (FALSE); return (showbuffer(bp, curwp, WFFULL | WFMODE)); } /* * Kill then re-open the requested dired buffer. * If required, take a note of any files marked for deletion. Then once * the buffer has been re-opened, remark the same files as deleted. */ struct buffer * refreshbuffer(struct buffer *bp) { char *tmp_b_fname; int i, tmp_w_dotline, ddel = 0; /* remember directory path to open later */ tmp_b_fname = strdup(bp->b_fname); if (tmp_b_fname == NULL) { dobeep(); ewprintf("Out of memory"); return (NULL); } tmp_w_dotline = curwp->w_dotline; /* create a list of files for deletion */ if (bp->b_flag & BFDIREDDEL) ddel = createlist(bp); killbuffer(bp); /* dired_() uses findbuffer() to create new buffer */ if ((bp = dired_(tmp_b_fname)) == NULL) { free(tmp_b_fname); return (NULL); } free(tmp_b_fname); /* remark any previously deleted files with a 'D' */ if (ddel) redelete(bp); /* find dot line */ bp->b_dotp = bfirstlp(bp); if (tmp_w_dotline > bp->b_lines) tmp_w_dotline = bp->b_lines - 1; for (i = 1; i < tmp_w_dotline; i++) bp->b_dotp = lforw(bp->b_dotp); bp->b_dotline = i; bp->b_doto = 0; d_warpdot(bp->b_dotp, &bp->b_doto); curbp = bp; return (bp); } static int d_makename(struct line *lp, char *fn, size_t len) { int start, nlen; char *namep; if (d_warpdot(lp, &start) == FALSE) return (ABORT); namep = &lp->l_text[start]; nlen = llength(lp) - start; if (snprintf(fn, len, "%s%.*s", curbp->b_fname, nlen, namep) >= len) return (ABORT); /* Name is too long. */ /* Return TRUE if the entry is a directory. */ return ((lgetc(lp, 2) == 'd') ? TRUE : FALSE); } #define NAME_FIELD 9 static int d_warpdot(struct line *dotp, int *doto) { char *tp = dotp->l_text; int off = 0, field = 0, len; /* * Find the byte offset to the (space-delimited) filename * field in formatted ls output. */ len = llength(dotp); while (off < len) { if (tp[off++] == ' ') { if (++field == NAME_FIELD) { *doto = off; return (TRUE); } /* Skip the space. */ while (off < len && tp[off] == ' ') off++; } } /* We didn't find the field. */ *doto = 0; return (FALSE); } static int d_forwpage(int f, int n) { forwpage(f | FFRAND, n); return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } static int d_backpage (int f, int n) { backpage(f | FFRAND, n); return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } static int d_forwline (int f, int n) { forwline(f | FFRAND, n); return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } static int d_backline (int f, int n) { backline(f | FFRAND, n); return (d_warpdot(curwp->w_dotp, &curwp->w_doto)); } int d_filevisitalt (int f, int n) { char fname[NFILEN]; if (d_makename(curwp->w_dotp, fname, sizeof(fname)) == ABORT) return (FALSE); return(do_filevisitalt(fname)); } /* * XXX dname needs to have enough place to store an additional '/'. */ struct buffer * dired_(char *dname) { struct buffer *bp; int i; size_t len; if ((dname = adjustname(dname, TRUE)) == NULL) { dobeep(); ewprintf("Bad directory name"); return (NULL); } /* this should not be done, instead adjustname() should get a flag */ len = strlen(dname); if (dname[len - 1] != '/') { dname[len++] = '/'; dname[len] = '\0'; } if ((access(dname, R_OK | X_OK)) == -1) { if (errno == EACCES) { dobeep(); ewprintf("Permission denied: %s", dname); } return (NULL); } for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (strcmp(bp->b_fname, dname) == 0) { if (fchecktime(bp) != TRUE) ewprintf("Directory has changed on disk;" " type g to update Dired"); return (bp); } } bp = bfind(dname, TRUE); bp->b_flag |= BFREADONLY | BFIGNDIRTY; if ((d_exec(2, bp, NULL, "ls", "-al", dname, NULL)) != TRUE) return (NULL); /* Find the line with ".." on it. */ bp->b_dotp = bfirstlp(bp); bp->b_dotline = 1; for (i = 0; i < bp->b_lines; i++) { bp->b_dotp = lforw(bp->b_dotp); bp->b_dotline++; if (d_warpdot(bp->b_dotp, &bp->b_doto) == FALSE) continue; if (strcmp(ltext(bp->b_dotp) + bp->b_doto, "..") == 0) break; } /* We want dot on the entry right after "..", if possible. */ if (++i < bp->b_lines - 2) { bp->b_dotp = lforw(bp->b_dotp); bp->b_dotline++; } d_warpdot(bp->b_dotp, &bp->b_doto); (void)strlcpy(bp->b_fname, dname, sizeof(bp->b_fname)); (void)strlcpy(bp->b_cwd, dname, sizeof(bp->b_cwd)); if ((bp->b_modes[1] = name_mode("dired")) == NULL) { bp->b_modes[0] = name_mode("fundamental"); dobeep(); ewprintf("Could not find mode dired"); return (NULL); } (void)fupdstat(bp); bp->b_nmodes = 1; return (bp); } /* * Iterate through the lines of the dired buffer looking for files * collected in the linked list made in createlist(). If a line is found * replace 'D' as first char in a line. As lines are found, remove the * corresponding item from the linked list. Iterate for as long as there * are items in the linked list or until end of buffer is found. */ void redelete(struct buffer *bp) { struct delentry *d1 = NULL; struct line *lp, *nlp; char fname[NFILEN]; char *p = fname; size_t plen, fnlen; int finished = 0; /* reset the deleted file buffer flag until a deleted file is found */ bp->b_flag &= ~BFDIREDDEL; for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) { bp->b_dotp = lp; if ((p = findfname(lp, p)) == NULL) { nlp = lforw(lp); continue; } plen = strlen(p); SLIST_FOREACH(d1, &delhead, entry) { fnlen = strlen(d1->fn); if ((plen == fnlen) && (strncmp(p, d1->fn, plen) == 0)) { lputc(bp->b_dotp, 0, DDELCHAR); bp->b_flag |= BFDIREDDEL; SLIST_REMOVE(&delhead, d1, delentry, entry); if (SLIST_EMPTY(&delhead)) { finished = 1; break; } } } if (finished) break; nlp = lforw(lp); } while (!SLIST_EMPTY(&delhead)) { d1 = SLIST_FIRST(&delhead); SLIST_REMOVE_HEAD(&delhead, entry); free(d1->fn); free(d1); } return; } /* * Create a list of files marked for deletion. */ int createlist(struct buffer *bp) { struct delentry *d1 = NULL, *d2; struct line *lp, *nlp; char fname[NFILEN]; char *p = fname; int ret = FALSE; for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) { /* * Check if the line has 'D' on the first char and if a valid * filename can be extracted from it. */ if (((lp->l_text[0] != DDELCHAR)) || ((p = findfname(lp, p)) == NULL)) { nlp = lforw(lp); continue; } if (SLIST_EMPTY(&delhead)) { if ((d1 = malloc(sizeof(struct delentry))) == NULL) return (ABORT); if ((d1->fn = strdup(p)) == NULL) { free(d1); return (ABORT); } SLIST_INSERT_HEAD(&delhead, d1, entry); } else { if ((d2 = malloc(sizeof(struct delentry))) == NULL) { free(d1->fn); free(d1); return (ABORT); } if ((d2->fn = strdup(p)) == NULL) { free(d1->fn); free(d1); free(d2); return (ABORT); } SLIST_INSERT_AFTER(d1, d2, entry); d1 = d2; } ret = TRUE; nlp = lforw(lp); } return (ret); } /* * Look for and extract a file name on a dired buffer line. */ char * findfname(struct line *lp, char *fn) { int start; (void)d_warpdot(lp, &start); if (start < 1) return NULL; fn = &lp->l_text[start]; return fn; } mg-20161005/display.c010064400017510001751000000641201276204442100130470ustar00hanboetes/* $OpenBSD: display.c,v 1.47 2015/04/03 22:10:29 bcallah Exp $ */ /* This file is in the public domain. */ /* * The functions in this file handle redisplay. The * redisplay system knows almost nothing about the editing * process; the editing functions do, however, set some * hints to eliminate a lot of the grinding. There is more * that can be done; the "vtputc" interface is a real * pig. */ #include #include #include #include #include #include #include #include "def.h" #include "kbd.h" /* * A video structure always holds * an array of characters whose length is equal to * the longest line possible. v_text is allocated * dynamically to fit the screen width. */ struct video { short v_hash; /* Hash code, for compares. */ short v_flag; /* Flag word. */ short v_color; /* Color of the line. */ int v_cost; /* Cost of display. */ char *v_text; /* The actual characters. */ }; #define VFCHG 0x0001 /* Changed. */ #define VFHBAD 0x0002 /* Hash and cost are bad. */ #define VFEXT 0x0004 /* extended line (beond ncol) */ /* * SCORE structures hold the optimal * trace trajectory, and the cost of redisplay, when * the dynamic programming redisplay code is used. */ struct score { int s_itrace; /* "i" index for track back. */ int s_jtrace; /* "j" index for trace back. */ int s_cost; /* Display cost. */ }; void vtmove(int, int); void vtputc(int); void vtpute(int); int vtputs(const char *); void vteeol(void); void updext(int, int); void modeline(struct mgwin *, int); void setscores(int, int); void traceback(int, int, int, int); void ucopy(struct video *, struct video *); void uline(int, struct video *, struct video *); void hash(struct video *); int sgarbf = TRUE; /* TRUE if screen is garbage. */ int vtrow = HUGE; /* Virtual cursor row. */ int vtcol = HUGE; /* Virtual cursor column. */ int tthue = CNONE; /* Current color. */ int ttrow = HUGE; /* Physical cursor row. */ int ttcol = HUGE; /* Physical cursor column. */ int tttop = HUGE; /* Top of scroll region. */ int ttbot = HUGE; /* Bottom of scroll region. */ int lbound = 0; /* leftmost bound of the current */ /* line being displayed */ struct video **vscreen; /* Edge vector, virtual. */ struct video **pscreen; /* Edge vector, physical. */ struct video *video; /* Actual screen data. */ struct video blanks; /* Blank line image. */ /* * This matrix is written as an array because * we do funny things in the "setscores" routine, which * is very compute intensive, to make the subscripts go away. * It would be "SCORE score[NROW][NROW]" in old speak. * Look at "setscores" to understand what is up. */ struct score *score; /* [NROW * NROW] */ static int linenos = TRUE; static int colnos = FALSE; /* Is macro recording enabled? */ extern int macrodef; /* Is working directory global? */ extern int globalwd; /* * Since we don't have variables (we probably should) these are command * processors for changing the values of mode flags. */ /* ARGSUSED */ int linenotoggle(int f, int n) { if (f & FFARG) linenos = n > 0; else linenos = !linenos; sgarbf = TRUE; return (TRUE); } /* ARGSUSED */ int colnotoggle(int f, int n) { if (f & FFARG) colnos = n > 0; else colnos = !colnos; sgarbf = TRUE; return (TRUE); } /* * Reinit the display data structures, this is called when the terminal * size changes. */ int vtresize(int force, int newrow, int newcol) { int i; int rowchanged, colchanged; static int first_run = 1; struct video *vp; if (newrow < 1 || newcol < 1) return (FALSE); rowchanged = (newrow != nrow); colchanged = (newcol != ncol); #define TRYREALLOC(a, n) do { \ void *tmp; \ if ((tmp = realloc((a), (n))) == NULL) { \ panic("out of memory in display code"); \ } \ (a) = tmp; \ } while (0) #define TRYREALLOCARRAY(a, n, m) do { \ void *tmp; \ if ((tmp = reallocarray((a), (n), (m))) == NULL) {\ panic("out of memory in display code"); \ } \ (a) = tmp; \ } while (0) /* No update needed */ if (!first_run && !force && !rowchanged && !colchanged) return (TRUE); if (first_run) memset(&blanks, 0, sizeof(blanks)); if (rowchanged || first_run) { int vidstart; /* * This is not pretty. */ if (nrow == 0) vidstart = 0; else vidstart = 2 * (nrow - 1); /* * We're shrinking, free some internal data. */ if (newrow < nrow) { for (i = 2 * (newrow - 1); i < 2 * (nrow - 1); i++) { free(video[i].v_text); video[i].v_text = NULL; } } TRYREALLOCARRAY(score, newrow, newrow * sizeof(struct score)); TRYREALLOCARRAY(vscreen, (newrow - 1), sizeof(struct video *)); TRYREALLOCARRAY(pscreen, (newrow - 1), sizeof(struct video *)); TRYREALLOCARRAY(video, (newrow - 1), 2 * sizeof(struct video)); /* * Zero-out the entries we just allocated. */ for (i = vidstart; i < 2 * (newrow - 1); i++) memset(&video[i], 0, sizeof(struct video)); /* * Reinitialize vscreen and pscreen arrays completely. */ vp = &video[0]; for (i = 0; i < newrow - 1; ++i) { vscreen[i] = vp; ++vp; pscreen[i] = vp; ++vp; } } if (rowchanged || colchanged || first_run) { for (i = 0; i < 2 * (newrow - 1); i++) TRYREALLOC(video[i].v_text, newcol); TRYREALLOC(blanks.v_text, newcol); } nrow = newrow; ncol = newcol; if (ttrow > nrow) ttrow = nrow; if (ttcol > ncol) ttcol = ncol; first_run = 0; return (TRUE); } #undef TRYREALLOC #undef TRYREALLOCARRAY /* * Initialize the data structures used * by the display code. The edge vectors used * to access the screens are set up. The operating * system's terminal I/O channel is set up. Fill the * "blanks" array with ASCII blanks. The rest is done * at compile time. The original window is marked * as needing full update, and the physical screen * is marked as garbage, so all the right stuff happens * on the first call to redisplay. */ void vtinit(void) { int i; ttopen(); ttinit(); /* * ttinit called ttresize(), which called vtresize(), so our data * structures are setup correctly. */ blanks.v_color = CTEXT; for (i = 0; i < ncol; ++i) blanks.v_text[i] = ' '; } /* * Tidy up the virtual display system * in anticipation of a return back to the host * operating system. Right now all we do is position * the cursor to the last line, erase the line, and * close the terminal channel. */ void vttidy(void) { ttcolor(CTEXT); ttnowindow(); /* No scroll window. */ ttmove(nrow - 1, 0); /* Echo line. */ tteeol(); tttidy(); ttflush(); ttclose(); } /* * Move the virtual cursor to an origin * 0 spot on the virtual display screen. I could * store the column as a character pointer to the spot * on the line, which would make "vtputc" a little bit * more efficient. No checking for errors. */ void vtmove(int row, int col) { vtrow = row; vtcol = col; } /* * Write a character to the virtual display, * dealing with long lines and the display of unprintable * things like control characters. Also expand tabs every 8 * columns. This code only puts printing characters into * the virtual display image. Special care must be taken when * expanding tabs. On a screen whose width is not a multiple * of 8, it is possible for the virtual cursor to hit the * right margin before the next tab stop is reached. This * makes the tab code loop if you are not careful. * Three guesses how we found this. */ void vtputc(int c) { struct video *vp; c &= 0xff; vp = vscreen[vtrow]; if (vtcol >= ncol) vp->v_text[ncol - 1] = '$'; else if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif ) { do { vtputc(' '); } while (vtcol < ncol && (vtcol & 0x07) != 0); } else if (ISCTRL(c)) { vtputc('^'); vtputc(CCHR(c)); } else if (isprint(c)) vp->v_text[vtcol++] = c; else { char bf[5]; snprintf(bf, sizeof(bf), "\\%o", c); vtputs(bf); } } /* * Put a character to the virtual screen in an extended line. If we are not * yet on left edge, don't print it yet. Check for overflow on the right * margin. */ void vtpute(int c) { struct video *vp; c &= 0xff; vp = vscreen[vtrow]; if (vtcol >= ncol) vp->v_text[ncol - 1] = '$'; else if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif ) { do { vtpute(' '); } while (((vtcol + lbound) & 0x07) != 0 && vtcol < ncol); } else if (ISCTRL(c) != FALSE) { vtpute('^'); vtpute(CCHR(c)); } else { if (vtcol >= 0) vp->v_text[vtcol] = c; ++vtcol; } } /* * Erase from the end of the software cursor to the end of the line on which * the software cursor is located. The display routines will decide if a * hardware erase to end of line command should be used to display this. */ void vteeol(void) { struct video *vp; vp = vscreen[vtrow]; while (vtcol < ncol) vp->v_text[vtcol++] = ' '; } /* * Make sure that the display is * right. This is a three part process. First, * scan through all of the windows looking for dirty * ones. Check the framing, and refresh the screen. * Second, make sure that "currow" and "curcol" are * correct for the current window. Third, make the * virtual and physical screens the same. */ void update(int modelinecolor) { struct line *lp; struct mgwin *wp; struct video *vp1; struct video *vp2; int c, i, j; int hflag; int currow, curcol; int offs, size; if (charswaiting()) return; if (sgarbf) { /* must update everything */ wp = wheadp; while (wp != NULL) { wp->w_rflag |= WFMODE | WFFULL; wp = wp->w_wndp; } } if (linenos || colnos) { wp = wheadp; while (wp != NULL) { wp->w_rflag |= WFMODE; wp = wp->w_wndp; } } hflag = FALSE; /* Not hard. */ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { /* * Nothing to be done. */ if (wp->w_rflag == 0) continue; if ((wp->w_rflag & WFFRAME) == 0) { lp = wp->w_linep; for (i = 0; i < wp->w_ntrows; ++i) { if (lp == wp->w_dotp) goto out; if (lp == wp->w_bufp->b_headp) break; lp = lforw(lp); } } /* * Put the middle-line in place. */ i = wp->w_frame; if (i > 0) { --i; if (i >= wp->w_ntrows) i = wp->w_ntrows - 1; } else if (i < 0) { i += wp->w_ntrows; if (i < 0) i = 0; } else i = wp->w_ntrows / 2; /* current center, no change */ /* * Find the line. */ lp = wp->w_dotp; while (i != 0 && lback(lp) != wp->w_bufp->b_headp) { --i; lp = lback(lp); } wp->w_linep = lp; wp->w_rflag |= WFFULL; /* Force full. */ out: lp = wp->w_linep; /* Try reduced update. */ i = wp->w_toprow; if ((wp->w_rflag & ~WFMODE) == WFEDIT) { while (lp != wp->w_dotp) { ++i; lp = lforw(lp); } vscreen[i]->v_color = CTEXT; vscreen[i]->v_flag |= (VFCHG | VFHBAD); vtmove(i, 0); for (j = 0; j < llength(lp); ++j) vtputc(lgetc(lp, j)); vteeol(); } else if ((wp->w_rflag & (WFEDIT | WFFULL)) != 0) { hflag = TRUE; while (i < wp->w_toprow + wp->w_ntrows) { vscreen[i]->v_color = CTEXT; vscreen[i]->v_flag |= (VFCHG | VFHBAD); vtmove(i, 0); if (lp != wp->w_bufp->b_headp) { for (j = 0; j < llength(lp); ++j) vtputc(lgetc(lp, j)); lp = lforw(lp); } vteeol(); ++i; } } if ((wp->w_rflag & WFMODE) != 0) modeline(wp, modelinecolor); wp->w_rflag = 0; wp->w_frame = 0; } lp = curwp->w_linep; /* Cursor location. */ currow = curwp->w_toprow; while (lp != curwp->w_dotp) { ++currow; lp = lforw(lp); } curcol = 0; i = 0; while (i < curwp->w_doto) { c = lgetc(lp, i++); if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif ) { curcol |= 0x07; curcol++; } else if (ISCTRL(c) != FALSE) curcol += 2; else if (isprint(c)) curcol++; else { char bf[5]; snprintf(bf, sizeof(bf), "\\%o", c); curcol += strlen(bf); } } if (curcol >= ncol - 1) { /* extended line. */ /* flag we are extended and changed */ vscreen[currow]->v_flag |= VFEXT | VFCHG; updext(currow, curcol); /* and output extended line */ } else lbound = 0; /* not extended line */ /* * Make sure no lines need to be de-extended because the cursor is no * longer on them. */ wp = wheadp; while (wp != NULL) { lp = wp->w_linep; i = wp->w_toprow; while (i < wp->w_toprow + wp->w_ntrows) { if (vscreen[i]->v_flag & VFEXT) { /* always flag extended lines as changed */ vscreen[i]->v_flag |= VFCHG; if ((wp != curwp) || (lp != wp->w_dotp) || (curcol < ncol - 1)) { vtmove(i, 0); for (j = 0; j < llength(lp); ++j) vtputc(lgetc(lp, j)); vteeol(); /* this line no longer is extended */ vscreen[i]->v_flag &= ~VFEXT; } } lp = lforw(lp); ++i; } /* if garbaged then fix up mode lines */ if (sgarbf != FALSE) vscreen[i]->v_flag |= VFCHG; /* and onward to the next window */ wp = wp->w_wndp; } if (sgarbf != FALSE) { /* Screen is garbage. */ sgarbf = FALSE; /* Erase-page clears. */ epresf = FALSE; /* The message area. */ tttop = HUGE; /* Forget where you set. */ ttbot = HUGE; /* scroll region. */ tthue = CNONE; /* Color unknown. */ ttmove(0, 0); tteeop(); for (i = 0; i < nrow - 1; ++i) { uline(i, vscreen[i], &blanks); ucopy(vscreen[i], pscreen[i]); } ttmove(currow, curcol - lbound); ttflush(); return; } if (hflag != FALSE) { /* Hard update? */ for (i = 0; i < nrow - 1; ++i) {/* Compute hash data. */ hash(vscreen[i]); hash(pscreen[i]); } offs = 0; /* Get top match. */ while (offs != nrow - 1) { vp1 = vscreen[offs]; vp2 = pscreen[offs]; if (vp1->v_color != vp2->v_color || vp1->v_hash != vp2->v_hash) break; uline(offs, vp1, vp2); ucopy(vp1, vp2); ++offs; } if (offs == nrow - 1) { /* Might get it all. */ ttmove(currow, curcol - lbound); ttflush(); return; } size = nrow - 1; /* Get bottom match. */ while (size != offs) { vp1 = vscreen[size - 1]; vp2 = pscreen[size - 1]; if (vp1->v_color != vp2->v_color || vp1->v_hash != vp2->v_hash) break; uline(size - 1, vp1, vp2); ucopy(vp1, vp2); --size; } if ((size -= offs) == 0) /* Get screen size. */ panic("Illegal screen size in update"); setscores(offs, size); /* Do hard update. */ traceback(offs, size, size, size); for (i = 0; i < size; ++i) ucopy(vscreen[offs + i], pscreen[offs + i]); ttmove(currow, curcol - lbound); ttflush(); return; } for (i = 0; i < nrow - 1; ++i) { /* Easy update. */ vp1 = vscreen[i]; vp2 = pscreen[i]; if ((vp1->v_flag & VFCHG) != 0) { uline(i, vp1, vp2); ucopy(vp1, vp2); } } ttmove(currow, curcol - lbound); ttflush(); } /* * Update a saved copy of a line, * kept in a video structure. The "vvp" is * the one in the "vscreen". The "pvp" is the one * in the "pscreen". This is called to make the * virtual and physical screens the same when * display has done an update. */ void ucopy(struct video *vvp, struct video *pvp) { vvp->v_flag &= ~VFCHG; /* Changes done. */ pvp->v_flag = vvp->v_flag; /* Update model. */ pvp->v_hash = vvp->v_hash; pvp->v_cost = vvp->v_cost; pvp->v_color = vvp->v_color; bcopy(vvp->v_text, pvp->v_text, ncol); } /* * updext: update the extended line which the cursor is currently on at a * column greater than the terminal width. The line will be scrolled right or * left to let the user see where the cursor is. */ void updext(int currow, int curcol) { struct line *lp; /* pointer to current line */ int j; /* index into line */ if (ncol < 2) return; /* * calculate what column the left bound should be * (force cursor into middle half of screen) */ lbound = curcol - (curcol % (ncol >> 1)) - (ncol >> 2); /* * scan through the line outputing characters to the virtual screen * once we reach the left edge */ vtmove(currow, -lbound); /* start scanning offscreen */ lp = curwp->w_dotp; /* line to output */ for (j = 0; j < llength(lp); ++j) /* until the end-of-line */ vtpute(lgetc(lp, j)); vteeol(); /* truncate the virtual line */ vscreen[currow]->v_text[0] = '$'; /* and put a '$' in column 1 */ } /* * Update a single line. This routine only * uses basic functionality (no insert and delete character, * but erase to end of line). The "vvp" points at the video * structure for the line on the virtual screen, and the "pvp" * is the same for the physical screen. Avoid erase to end of * line when updating CMODE color lines, because of the way that * reverse video works on most terminals. */ void uline(int row, struct video *vvp, struct video *pvp) { char *cp1; char *cp2; char *cp3; char *cp4; char *cp5; int nbflag; if (vvp->v_color != pvp->v_color) { /* Wrong color, do a */ ttmove(row, 0); /* full redraw. */ #ifdef STANDOUT_GLITCH if (pvp->v_color != CTEXT && magic_cookie_glitch >= 0) tteeol(); #endif ttcolor(vvp->v_color); #ifdef STANDOUT_GLITCH cp1 = &vvp->v_text[magic_cookie_glitch > 0 ? magic_cookie_glitch : 0]; /* * The odd code for magic_cookie_glitch==0 is to avoid * putting the invisible glitch character on the next line. * (Hazeltine executive 80 model 30) */ cp2 = &vvp->v_text[ncol - (magic_cookie_glitch >= 0 ? (magic_cookie_glitch != 0 ? magic_cookie_glitch : 1) : 0)]; #else cp1 = &vvp->v_text[0]; cp2 = &vvp->v_text[ncol]; #endif while (cp1 != cp2) { ttputc(*cp1++); ++ttcol; } ttcolor(CTEXT); return; } cp1 = &vvp->v_text[0]; /* Compute left match. */ cp2 = &pvp->v_text[0]; while (cp1 != &vvp->v_text[ncol] && cp1[0] == cp2[0]) { ++cp1; ++cp2; } if (cp1 == &vvp->v_text[ncol]) /* All equal. */ return; nbflag = FALSE; cp3 = &vvp->v_text[ncol]; /* Compute right match. */ cp4 = &pvp->v_text[ncol]; while (cp3[-1] == cp4[-1]) { --cp3; --cp4; if (cp3[0] != ' ') /* Note non-blanks in */ nbflag = TRUE; /* the right match. */ } cp5 = cp3; /* Is erase good? */ if (nbflag == FALSE && vvp->v_color == CTEXT) { while (cp5 != cp1 && cp5[-1] == ' ') --cp5; /* Alcyon hack */ if ((int) (cp3 - cp5) <= tceeol) cp5 = cp3; } /* Alcyon hack */ ttmove(row, (int) (cp1 - &vvp->v_text[0])); #ifdef STANDOUT_GLITCH if (vvp->v_color != CTEXT && magic_cookie_glitch > 0) { if (cp1 < &vvp->v_text[magic_cookie_glitch]) cp1 = &vvp->v_text[magic_cookie_glitch]; if (cp5 > &vvp->v_text[ncol - magic_cookie_glitch]) cp5 = &vvp->v_text[ncol - magic_cookie_glitch]; } else if (magic_cookie_glitch < 0) #endif ttcolor(vvp->v_color); while (cp1 != cp5) { ttputc(*cp1++); ++ttcol; } if (cp5 != cp3) /* Do erase. */ tteeol(); } /* * Redisplay the mode line for the window pointed to by the "wp". * This is the only routine that has any idea of how the mode line is * formatted. You can change the modeline format by hacking at this * routine. Called by "update" any time there is a dirty window. Note * that if STANDOUT_GLITCH is defined, first and last magic_cookie_glitch * characters may never be seen. */ void modeline(struct mgwin *wp, int modelinecolor) { int n, md; struct buffer *bp; char sl[21]; /* Overkill. Space for 2^64 in base 10. */ int len; n = wp->w_toprow + wp->w_ntrows; /* Location. */ vscreen[n]->v_color = modelinecolor; /* Mode line color. */ vscreen[n]->v_flag |= (VFCHG | VFHBAD); /* Recompute, display. */ vtmove(n, 0); /* Seek to right line. */ bp = wp->w_bufp; vtputc('-'); vtputc('-'); if ((bp->b_flag & BFREADONLY) != 0) { vtputc('%'); if ((bp->b_flag & BFCHG) != 0) vtputc('*'); else vtputc('%'); } else if ((bp->b_flag & BFCHG) != 0) { /* "*" if changed. */ vtputc('*'); vtputc('*'); } else { vtputc('-'); vtputc('-'); } vtputc('-'); n = 5; n += vtputs("Mg: "); if (bp->b_bname[0] != '\0') n += vtputs(&(bp->b_bname[0])); while (n < 42) { /* Pad out with blanks. */ vtputc(' '); ++n; } vtputc('('); ++n; for (md = 0; ; ) { n += vtputs(bp->b_modes[md]->p_name); if (++md > bp->b_nmodes) break; vtputc('-'); ++n; } /* XXX These should eventually move to a real mode */ if (macrodef == TRUE) n += vtputs("-def"); if (globalwd == TRUE) n += vtputs("-gwd"); vtputc(')'); ++n; if (linenos && colnos) len = snprintf(sl, sizeof(sl), "--L%d--C%d", wp->w_dotline, getcolpos(wp)); else if (linenos) len = snprintf(sl, sizeof(sl), "--L%d", wp->w_dotline); else if (colnos) len = snprintf(sl, sizeof(sl), "--C%d", getcolpos(wp)); if ((linenos || colnos) && len < sizeof(sl) && len != -1) n += vtputs(sl); while (n < ncol) { /* Pad out. */ vtputc('-'); ++n; } } /* * Output a string to the mode line, report how long it was. */ int vtputs(const char *s) { int n = 0; while (*s != '\0') { vtputc(*s++); ++n; } return (n); } /* * Compute the hash code for the line pointed to by the "vp". * Recompute it if necessary. Also set the approximate redisplay * cost. The validity of the hash code is marked by a flag bit. * The cost understand the advantages of erase to end of line. * Tuned for the VAX by Bob McNamara; better than it used to be on * just about any machine. */ void hash(struct video *vp) { int i, n; char *s; if ((vp->v_flag & VFHBAD) != 0) { /* Hash bad. */ s = &vp->v_text[ncol - 1]; for (i = ncol; i != 0; --i, --s) if (*s != ' ') break; n = ncol - i; /* Erase cheaper? */ if (n > tceeol) n = tceeol; vp->v_cost = i + n; /* Bytes + blanks. */ for (n = 0; i != 0; --i, --s) n = (n << 5) + n + *s; vp->v_hash = n; /* Hash code. */ vp->v_flag &= ~VFHBAD; /* Flag as all done. */ } } /* * Compute the Insert-Delete * cost matrix. The dynamic programming algorithm * described by James Gosling is used. This code assumes * that the line above the echo line is the last line involved * in the scroll region. This is easy to arrange on the VT100 * because of the scrolling region. The "offs" is the origin 0 * offset of the first row in the virtual/physical screen that * is being updated; the "size" is the length of the chunk of * screen being updated. For a full screen update, use offs=0 * and size=nrow-1. * * Older versions of this code implemented the score matrix by * a two dimensional array of SCORE nodes. This put all kinds of * multiply instructions in the code! This version is written to * use a linear array and pointers, and contains no multiplication * at all. The code has been carefully looked at on the VAX, with * only marginal checking on other machines for efficiency. In * fact, this has been tuned twice! Bob McNamara tuned it even * more for the VAX, which is a big issue for him because of * the 66 line X displays. * * On some machines, replacing the "for (i=1; i<=size; ++i)" with * i = 1; do { } while (++i <=size)" will make the code quite a * bit better; but it looks ugly. */ void setscores(int offs, int size) { struct score *sp; struct score *sp1; struct video **vp, **pp; struct video **vbase, **pbase; int tempcost; int bestcost; int j, i; vbase = &vscreen[offs - 1]; /* By hand CSE's. */ pbase = &pscreen[offs - 1]; score[0].s_itrace = 0; /* [0, 0] */ score[0].s_jtrace = 0; score[0].s_cost = 0; sp = &score[1]; /* Row 0, inserts. */ tempcost = 0; vp = &vbase[1]; for (j = 1; j <= size; ++j) { sp->s_itrace = 0; sp->s_jtrace = j - 1; tempcost += tcinsl; tempcost += (*vp)->v_cost; sp->s_cost = tempcost; ++vp; ++sp; } sp = &score[nrow]; /* Column 0, deletes. */ tempcost = 0; for (i = 1; i <= size; ++i) { sp->s_itrace = i - 1; sp->s_jtrace = 0; tempcost += tcdell; sp->s_cost = tempcost; sp += nrow; } sp1 = &score[nrow + 1]; /* [1, 1]. */ pp = &pbase[1]; for (i = 1; i <= size; ++i) { sp = sp1; vp = &vbase[1]; for (j = 1; j <= size; ++j) { sp->s_itrace = i - 1; sp->s_jtrace = j; bestcost = (sp - nrow)->s_cost; if (j != size) /* Cd(A[i])=0 @ Dis. */ bestcost += tcdell; tempcost = (sp - 1)->s_cost; tempcost += (*vp)->v_cost; if (i != size) /* Ci(B[j])=0 @ Dsj. */ tempcost += tcinsl; if (tempcost < bestcost) { sp->s_itrace = i; sp->s_jtrace = j - 1; bestcost = tempcost; } tempcost = (sp - nrow - 1)->s_cost; if ((*pp)->v_color != (*vp)->v_color || (*pp)->v_hash != (*vp)->v_hash) tempcost += (*vp)->v_cost; if (tempcost < bestcost) { sp->s_itrace = i - 1; sp->s_jtrace = j - 1; bestcost = tempcost; } sp->s_cost = bestcost; ++sp; /* Next column. */ ++vp; } ++pp; sp1 += nrow; /* Next row. */ } } /* * Trace back through the dynamic programming cost * matrix, and update the screen using an optimal sequence * of redraws, insert lines, and delete lines. The "offs" is * the origin 0 offset of the chunk of the screen we are about to * update. The "i" and "j" are always started in the lower right * corner of the matrix, and imply the size of the screen. * A full screen traceback is called with offs=0 and i=j=nrow-1. * There is some do-it-yourself double subscripting here, * which is acceptable because this routine is much less compute * intensive then the code that builds the score matrix! */ void traceback(int offs, int size, int i, int j) { int itrace, jtrace; int k; int ninsl, ndraw, ndell; if (i == 0 && j == 0) /* End of update. */ return; itrace = score[(nrow * i) + j].s_itrace; jtrace = score[(nrow * i) + j].s_jtrace; if (itrace == i) { /* [i, j-1] */ ninsl = 0; /* Collect inserts. */ if (i != size) ninsl = 1; ndraw = 1; while (itrace != 0 || jtrace != 0) { if (score[(nrow * itrace) + jtrace].s_itrace != itrace) break; jtrace = score[(nrow * itrace) + jtrace].s_jtrace; if (i != size) ++ninsl; ++ndraw; } traceback(offs, size, itrace, jtrace); if (ninsl != 0) { ttcolor(CTEXT); ttinsl(offs + j - ninsl, offs + size - 1, ninsl); } do { /* B[j], A[j] blank. */ k = offs + j - ndraw; uline(k, vscreen[k], &blanks); } while (--ndraw); return; } if (jtrace == j) { /* [i-1, j] */ ndell = 0; /* Collect deletes. */ if (j != size) ndell = 1; while (itrace != 0 || jtrace != 0) { if (score[(nrow * itrace) + jtrace].s_jtrace != jtrace) break; itrace = score[(nrow * itrace) + jtrace].s_itrace; if (j != size) ++ndell; } if (ndell != 0) { ttcolor(CTEXT); ttdell(offs + i - ndell, offs + size - 1, ndell); } traceback(offs, size, itrace, jtrace); return; } traceback(offs, size, itrace, jtrace); k = offs + j - 1; uline(k, vscreen[k], pscreen[offs + i - 1]); } mg-20161005/echo.c010064400017510001751000000516741276204442100123320ustar00hanboetes/* $OpenBSD: echo.c,v 1.65 2015/12/05 02:14:02 jsg Exp $ */ /* This file is in the public domain. */ /* * Echo line reading and writing. * * Common routines for reading and writing characters in the echo line area * of the display screen. Used by the entire known universe. */ #include #include #include #include #include #include #include #include "def.h" #include "funmap.h" #include "key.h" #include "macro.h" static char *veread(const char *, char *, size_t, int, va_list) __attribute__((__format__ (printf, 1, 0))); static int complt(int, int, char *, size_t, int, int *); static int complt_list(int, char *, int); static void eformat(const char *, va_list) __attribute__((__format__ (printf, 1, 0)));; static void eputi(int, int); static void eputl(long, int); static void eputs(const char *); static void eputc(char); static struct list *copy_list(struct list *); int epresf = FALSE; /* stuff in echo line flag */ /* * Erase the echo line. */ void eerase(void) { ttcolor(CTEXT); ttmove(nrow - 1, 0); tteeol(); ttflush(); epresf = FALSE; } /* * Ask a "yes" or "no" question. Return ABORT if the user answers the * question with the abort ("^G") character. Return FALSE for "no" and * TRUE for "yes". No formatting services are available. No newline * required. */ int eyorn(const char *sp) { int s; if (inmacro) return (TRUE); ewprintf("%s? (y or n) ", sp); for (;;) { s = getkey(FALSE); if (s == 'y' || s == 'Y' || s == ' ') { ewprintf(""); return (TRUE); } if (s == 'n' || s == 'N' || s == CCHR('M')) { ewprintf(""); return (FALSE); } if (s == CCHR('G')) { ewprintf(""); return (ctrlg(FFRAND, 1)); } ewprintf("Please answer y or n. %s? (y or n) ", sp); } /* NOTREACHED */ } /* * Ask a "yes", "no" or "revert" question. Return ABORT if the user answers * the question with the abort ("^G") character. Return FALSE for "no", * TRUE for "yes" and REVERT for "revert". No formatting services are * available. No newline required. */ int eynorr(const char *sp) { int s; if (inmacro) return (TRUE); ewprintf("%s? (y, n or r) ", sp); for (;;) { s = getkey(FALSE); if (s == 'y' || s == 'Y' || s == ' ') { ewprintf(""); return (TRUE); } if (s == 'n' || s == 'N' || s == CCHR('M')) { ewprintf(""); return (FALSE); } if (s == 'r' || s == 'R') { ewprintf(""); return (REVERT); } if (s == CCHR('G')) { ewprintf(""); return (ctrlg(FFRAND, 1)); } ewprintf("Please answer y, n or r."); } /* NOTREACHED */ } /* * Like eyorn, but for more important questions. User must type all of * "yes" or "no" and the trailing newline. */ int eyesno(const char *sp) { char buf[64], *rep; if (inmacro) return (TRUE); rep = eread("%s? (yes or no) ", buf, sizeof(buf), EFNUL | EFNEW | EFCR, sp); for (;;) { if (rep == NULL) { ewprintf(""); return (ABORT); } if (rep[0] != '\0') { if (macrodef) { struct line *lp = maclcur; maclcur = lp->l_bp; maclcur->l_fp = lp->l_fp; free(lp); } if (strcasecmp(rep, "yes") == 0) { ewprintf(""); return (TRUE); } if (strcasecmp(rep, "no") == 0) { ewprintf(""); return (FALSE); } } rep = eread("Please answer yes or no. %s? (yes or no) ", buf, sizeof(buf), EFNUL | EFNEW | EFCR, sp); } /* NOTREACHED */ } /* * This is the general "read input from the echo line" routine. The basic * idea is that the prompt string "prompt" is written to the echo line, and * a one line reply is read back into the supplied "buf" (with maximum * length "len"). * XXX: When checking for an empty return value, always check rep, *not* buf * as buf may be freed in pathological cases. */ char * eread(const char *fmt, char *buf, size_t nbuf, int flag, ...) { va_list ap; char *rep; va_start(ap, flag); rep = veread(fmt, buf, nbuf, flag, ap); va_end(ap); return (rep); } static char * veread(const char *fp, char *buf, size_t nbuf, int flag, va_list ap) { int dynbuf = (buf == NULL); int cpos, epos; /* cursor, end position in buf */ int c, i, y; int cplflag; /* display completion list */ int cwin = FALSE; /* completion list created */ int mr, ml; /* match left/right arrows */ int esc; /* position in esc pattern */ struct buffer *bp; /* completion list buffer */ struct mgwin *wp; /* window for compl list */ int match; /* esc match found */ int cc, rr; /* saved ttcol, ttrow */ char *ret; /* return value */ static char emptyval[] = ""; /* XXX hackish way to return err msg*/ if (inmacro) { if (dynbuf) { if ((buf = malloc(maclcur->l_used + 1)) == NULL) return (NULL); } else if (maclcur->l_used >= nbuf) return (NULL); bcopy(maclcur->l_text, buf, maclcur->l_used); buf[maclcur->l_used] = '\0'; maclcur = maclcur->l_fp; return (buf); } epos = cpos = 0; ml = mr = esc = 0; cplflag = FALSE; if ((flag & EFNEW) != 0 || ttrow != nrow - 1) { ttcolor(CTEXT); ttmove(nrow - 1, 0); epresf = TRUE; } else eputc(' '); eformat(fp, ap); if ((flag & EFDEF) != 0) { if (buf == NULL) return (NULL); eputs(buf); epos = cpos += strlen(buf); } tteeol(); ttflush(); for (;;) { c = getkey(FALSE); if ((flag & EFAUTO) != 0 && c == CCHR('I')) { if (cplflag == TRUE) { complt_list(flag, buf, cpos); cwin = TRUE; } else if (complt(flag, c, buf, nbuf, epos, &i) == TRUE) { cplflag = TRUE; epos += i; cpos = epos; } continue; } cplflag = FALSE; if (esc > 0) { /* ESC sequence started */ match = 0; if (ml == esc && key_left[ml] && c == key_left[ml]) { match++; if (key_left[++ml] == '\0') { c = CCHR('B'); esc = 0; } } if (mr == esc && key_right[mr] && c == key_right[mr]) { match++; if (key_right[++mr] == '\0') { c = CCHR('F'); esc = 0; } } if (match == 0) { esc = 0; continue; /* hack. how do we know esc pattern is done? */ } if (esc > 0) { esc++; continue; } } switch (c) { case CCHR('A'): /* start of line */ while (cpos > 0) { if (ISCTRL(buf[--cpos]) != FALSE) { ttputc('\b'); --ttcol; } ttputc('\b'); --ttcol; } ttflush(); break; case CCHR('D'): if (cpos != epos) { tteeol(); epos--; rr = ttrow; cc = ttcol; for (i = cpos; i < epos; i++) { buf[i] = buf[i + 1]; eputc(buf[i]); } ttmove(rr, cc); ttflush(); } break; case CCHR('E'): /* end of line */ while (cpos < epos) { eputc(buf[cpos++]); } ttflush(); break; case CCHR('B'): /* back */ if (cpos > 0) { if (ISCTRL(buf[--cpos]) != FALSE) { ttputc('\b'); --ttcol; } ttputc('\b'); --ttcol; ttflush(); } break; case CCHR('F'): /* forw */ if (cpos < epos) { eputc(buf[cpos++]); ttflush(); } break; case CCHR('Y'): /* yank from kill buffer */ i = 0; while ((y = kremove(i++)) >= 0 && y != '\n') { int t; if (dynbuf && epos + 1 >= nbuf) { void *newp; size_t newsize = epos + epos + 16; if ((newp = realloc(buf, newsize)) == NULL) goto memfail; buf = newp; nbuf = newsize; } if (!dynbuf && epos + 1 >= nbuf) { dobeep(); ewprintf("Line too long"); return (emptyval); } for (t = epos; t > cpos; t--) buf[t] = buf[t - 1]; buf[cpos++] = (char)y; epos++; eputc((char)y); cc = ttcol; rr = ttrow; for (t = cpos; t < epos; t++) eputc(buf[t]); ttmove(rr, cc); } ttflush(); break; case CCHR('K'): /* copy here-EOL to kill buffer */ kdelete(); for (i = cpos; i < epos; i++) kinsert(buf[i], KFORW); tteeol(); epos = cpos; ttflush(); break; case CCHR('['): ml = mr = esc = 1; break; case CCHR('J'): c = CCHR('M'); /* FALLTHROUGH */ case CCHR('M'): /* return, done */ /* if there's nothing in the minibuffer, abort */ if (epos == 0 && !(flag & EFNUL)) { (void)ctrlg(FFRAND, 0); ttflush(); return (NULL); } if ((flag & EFFUNC) != 0) { if (complt(flag, c, buf, nbuf, epos, &i) == FALSE) continue; if (i > 0) epos += i; } buf[epos] = '\0'; if ((flag & EFCR) != 0) { ttputc(CCHR('M')); ttflush(); } if (macrodef) { struct line *lp; if ((lp = lalloc(cpos)) == NULL) goto memfail; lp->l_fp = maclcur->l_fp; maclcur->l_fp = lp; lp->l_bp = maclcur; maclcur = lp; bcopy(buf, lp->l_text, cpos); } ret = buf; goto done; case CCHR('G'): /* bell, abort */ eputc(CCHR('G')); (void)ctrlg(FFRAND, 0); ttflush(); ret = NULL; goto done; case CCHR('H'): /* rubout, erase */ case CCHR('?'): if (cpos != 0) { y = buf[--cpos]; epos--; ttputc('\b'); ttcol--; if (ISCTRL(y) != FALSE) { ttputc('\b'); ttcol--; } rr = ttrow; cc = ttcol; for (i = cpos; i < epos; i++) { buf[i] = buf[i + 1]; eputc(buf[i]); } ttputc(' '); if (ISCTRL(y) != FALSE) { ttputc(' '); ttputc('\b'); } ttputc('\b'); ttmove(rr, cc); ttflush(); } break; case CCHR('X'): /* kill line */ case CCHR('U'): while (cpos != 0) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; if (ISCTRL(buf[--cpos]) != FALSE) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; } epos--; } ttflush(); break; case CCHR('W'): /* kill to beginning of word */ while ((cpos > 0) && !ISWORD(buf[cpos - 1])) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; if (ISCTRL(buf[--cpos]) != FALSE) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; } epos--; } while ((cpos > 0) && ISWORD(buf[cpos - 1])) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; if (ISCTRL(buf[--cpos]) != FALSE) { ttputc('\b'); ttputc(' '); ttputc('\b'); --ttcol; } epos--; } ttflush(); break; case CCHR('\\'): case CCHR('Q'): /* quote next */ c = getkey(FALSE); /* FALLTHROUGH */ default: if (dynbuf && epos + 1 >= nbuf) { void *newp; size_t newsize = epos + epos + 16; if ((newp = realloc(buf, newsize)) == NULL) goto memfail; buf = newp; nbuf = newsize; } if (!dynbuf && epos + 1 >= nbuf) { dobeep(); ewprintf("Line too long"); return (emptyval); } for (i = epos; i > cpos; i--) buf[i] = buf[i - 1]; buf[cpos++] = (char)c; epos++; eputc((char)c); cc = ttcol; rr = ttrow; for (i = cpos; i < epos; i++) eputc(buf[i]); ttmove(rr, cc); ttflush(); } } done: if (cwin == TRUE) { /* blow away cpltion window */ bp = bfind("*Completions*", TRUE); if ((wp = popbuf(bp, WEPHEM)) != NULL) { if (wp->w_flag & WEPHEM) { curwp = wp; delwind(FFRAND, 1); } else { killbuffer(bp); } } } return (ret); memfail: if (dynbuf && buf) free(buf); dobeep(); ewprintf("Out of memory"); return (emptyval); } /* * Do completion on a list of objects. * c is SPACE, TAB, or CR * return TRUE if matched (or partially matched) * FALSE is result is ambiguous, * ABORT on error. */ static int complt(int flags, int c, char *buf, size_t nbuf, int cpos, int *nx) { struct list *lh, *lh2; struct list *wholelist = NULL; int i, nxtra, nhits, bxtra, msglen, nshown; int wflag = FALSE; char *msg; lh = lh2 = NULL; if ((flags & EFFUNC) != 0) { buf[cpos] = '\0'; wholelist = lh = complete_function_list(buf); } else if ((flags & EFBUF) != 0) { lh = &(bheadp->b_list); } else if ((flags & EFFILE) != 0) { buf[cpos] = '\0'; wholelist = lh = make_file_list(buf); } else panic("broken complt call: flags"); if (c == ' ') wflag = TRUE; else if (c != '\t' && c != CCHR('M')) panic("broken complt call: c"); nhits = 0; nxtra = HUGE; for (; lh != NULL; lh = lh->l_next) { if (memcmp(buf, lh->l_name, cpos) != 0) continue; if (nhits == 0) lh2 = lh; ++nhits; if (lh->l_name[cpos] == '\0') nxtra = -1; /* exact match */ else { bxtra = getxtra(lh, lh2, cpos, wflag); if (bxtra < nxtra) nxtra = bxtra; lh2 = lh; } } if (nhits == 0) msg = " [No match]"; else if (nhits > 1 && nxtra == 0) msg = " [Ambiguous. Ctrl-G to cancel]"; else { /* * Being lazy - ought to check length, but all things * autocompleted have known types/lengths. */ if (nxtra < 0 && nhits > 1 && c == ' ') nxtra = 1; /* ??? */ for (i = 0; i < nxtra && cpos < nbuf; ++i) { buf[cpos] = lh2->l_name[cpos]; eputc(buf[cpos++]); } /* XXX should grow nbuf */ ttflush(); free_file_list(wholelist); *nx = nxtra; if (nxtra < 0 && c != CCHR('M')) /* exact */ *nx = 0; return (TRUE); } /* * wholelist is NULL if we are doing buffers. Want to free lists * that were created for us, but not the buffer list! */ free_file_list(wholelist); /* Set up backspaces, etc., being mindful of echo line limit. */ msglen = strlen(msg); nshown = (ttcol + msglen + 2 > ncol) ? ncol - ttcol - 2 : msglen; eputs(msg); ttcol -= (i = nshown); /* update ttcol! */ while (i--) /* move back before msg */ ttputc('\b'); ttflush(); /* display to user */ i = nshown; while (i--) /* blank out on next flush */ eputc(' '); ttcol -= (i = nshown); /* update ttcol on BS's */ while (i--) ttputc('\b'); /* update ttcol again! */ *nx = nxtra; return ((nhits > 0) ? TRUE : FALSE); } /* * Do completion on a list of objects, listing instead of completing. */ static int complt_list(int flags, char *buf, int cpos) { struct list *lh, *lh2, *lh3; struct list *wholelist = NULL; struct buffer *bp; int i, maxwidth, width; int preflen = 0; int oldrow = ttrow; int oldcol = ttcol; int oldhue = tthue; char *linebuf; size_t linesize, len; char *cp; lh = NULL; ttflush(); /* The results are put into a completion buffer. */ bp = bfind("*Completions*", TRUE); if (bclear(bp) == FALSE) return (FALSE); bp->b_flag |= BFREADONLY; /* * First get the list of objects. This list may contain only * the ones that complete what has been typed, or may be the * whole list of all objects of this type. They are filtered * later in any case. Set wholelist if the list has been * cons'ed up just for us, so we can free it later. We have * to copy the buffer list for this function even though we * didn't for complt. The sorting code does destructive * changes to the list, which we don't want to happen to the * main buffer list! */ if ((flags & EFBUF) != 0) wholelist = lh = copy_list(&(bheadp->b_list)); else if ((flags & EFFUNC) != 0) { buf[cpos] = '\0'; wholelist = lh = complete_function_list(buf); } else if ((flags & EFFILE) != 0) { buf[cpos] = '\0'; wholelist = lh = make_file_list(buf); /* * We don't want to display stuff up to the / for file * names preflen is the list of a prefix of what the * user typed that should not be displayed. */ cp = strrchr(buf, '/'); if (cp) preflen = cp - buf + 1; } else panic("broken complt call: flags"); /* * Sort the list, since users expect to see it in alphabetic * order. */ lh2 = lh; while (lh2 != NULL) { lh3 = lh2->l_next; while (lh3 != NULL) { if (strcmp(lh2->l_name, lh3->l_name) > 0) { cp = lh2->l_name; lh2->l_name = lh3->l_name; lh3->l_name = cp; } lh3 = lh3->l_next; } lh2 = lh2->l_next; } /* * First find max width of object to be displayed, so we can * put several on a line. */ maxwidth = 0; lh2 = lh; while (lh2 != NULL) { for (i = 0; i < cpos; ++i) { if (buf[i] != lh2->l_name[i]) break; } if (i == cpos) { width = strlen(lh2->l_name); if (width > maxwidth) maxwidth = width; } lh2 = lh2->l_next; } maxwidth += 1 - preflen; /* * Now do the display. Objects are written into linebuf until * it fills, and then put into the help buffer. */ linesize = (ncol > maxwidth ? ncol : maxwidth) + 1; if ((linebuf = malloc(linesize)) == NULL) { free_file_list(wholelist); return (FALSE); } width = 0; /* * We're going to strlcat() into the buffer, so it has to be * NUL terminated. */ linebuf[0] = '\0'; for (lh2 = lh; lh2 != NULL; lh2 = lh2->l_next) { for (i = 0; i < cpos; ++i) { if (buf[i] != lh2->l_name[i]) break; } /* if we have a match */ if (i == cpos) { /* if it wraps */ if ((width + maxwidth) > ncol) { addline(bp, linebuf); linebuf[0] = '\0'; width = 0; } len = strlcat(linebuf, lh2->l_name + preflen, linesize); width += maxwidth; if (len < width && width < linesize) { /* pad so the objects nicely line up */ memset(linebuf + len, ' ', maxwidth - strlen(lh2->l_name + preflen)); linebuf[width] = '\0'; } } } if (width > 0) addline(bp, linebuf); free(linebuf); /* * Note that we free lists only if they are put in wholelist lists * that were built just for us should be freed. However when we use * the buffer list, obviously we don't want it freed. */ free_file_list(wholelist); popbuftop(bp, WEPHEM); /* split the screen and put up the help * buffer */ update(CMODE); /* needed to make the new stuff actually * appear */ ttmove(oldrow, oldcol); /* update leaves cursor in arbitrary place */ ttcolor(oldhue); /* with arbitrary color */ ttflush(); return (0); } /* * The "lp1" and "lp2" point to list structures. The "cpos" is a horizontal * position in the name. Return the longest block of characters that can be * autocompleted at this point. Sometimes the two symbols are the same, but * this is normal. */ int getxtra(struct list *lp1, struct list *lp2, int cpos, int wflag) { int i; i = cpos; for (;;) { if (lp1->l_name[i] != lp2->l_name[i]) break; if (lp1->l_name[i] == '\0') break; ++i; if (wflag && !ISWORD(lp1->l_name[i - 1])) break; } return (i - cpos); } /* * Special "printf" for the echo line. Each call to "ewprintf" starts a * new line in the echo area, and ends with an erase to end of the echo * line. The formatting is done by a call to the standard formatting * routine. */ void ewprintf(const char *fmt, ...) { va_list ap; if (inmacro) return; va_start(ap, fmt); ttcolor(CTEXT); ttmove(nrow - 1, 0); eformat(fmt, ap); va_end(ap); tteeol(); ttflush(); epresf = TRUE; } /* * Printf style formatting. This is called by "ewprintf" to provide * formatting services to its clients. The move to the start of the * echo line, and the erase to the end of the echo line, is done by * the caller. * %c prints the "name" of the supplied character. * %k prints the name of the current key (and takes no arguments). * %d prints a decimal integer * %o prints an octal integer * %p prints a pointer * %s prints a string * %ld prints a long word * Anything else is echoed verbatim */ static void eformat(const char *fp, va_list ap) { char kname[NKNAME], tmp[100], *cp; int c; while ((c = *fp++) != '\0') { if (c != '%') eputc(c); else { c = *fp++; switch (c) { case 'c': getkeyname(kname, sizeof(kname), va_arg(ap, int)); eputs(kname); break; case 'k': for (cp = kname, c = 0; c < key.k_count; c++) { if (c) *cp++ = ' '; cp = getkeyname(cp, sizeof(kname) - (cp - kname) - 1, key.k_chars[c]); } eputs(kname); break; case 'd': eputi(va_arg(ap, int), 10); break; case 'o': eputi(va_arg(ap, int), 8); break; case 'p': snprintf(tmp, sizeof(tmp), "%p", va_arg(ap, void *)); eputs(tmp); break; case 's': eputs(va_arg(ap, char *)); break; case 'l': /* explicit longword */ c = *fp++; switch (c) { case 'd': eputl(va_arg(ap, long), 10); break; default: eputc(c); break; } break; default: eputc(c); } } } } /* * Put integer, in radix "r". */ static void eputi(int i, int r) { int q; if (i < 0) { eputc('-'); i = -i; } if ((q = i / r) != 0) eputi(q, r); eputc(i % r + '0'); } /* * Put long, in radix "r". */ static void eputl(long l, int r) { long q; if (l < 0) { eputc('-'); l = -l; } if ((q = l / r) != 0) eputl(q, r); eputc((int)(l % r) + '0'); } /* * Put string. */ static void eputs(const char *s) { int c; while ((c = *s++) != '\0') eputc(c); } /* * Put character. Watch for control characters, and for the line getting * too long. */ static void eputc(char c) { if (ttcol + 2 < ncol) { if (ISCTRL(c)) { eputc('^'); c = CCHR(c); } ttputc(c); ++ttcol; } } void free_file_list(struct list *lp) { struct list *next; while (lp) { next = lp->l_next; free(lp->l_name); free(lp); lp = next; } } static struct list * copy_list(struct list *lp) { struct list *current, *last, *nxt; last = NULL; while (lp) { current = malloc(sizeof(struct list)); if (current == NULL) { /* Free what we have allocated so far */ for (current = last; current; current = nxt) { nxt = current->l_next; free(current->l_name); free(current); } return (NULL); } current->l_next = last; current->l_name = strdup(lp->l_name); last = current; lp = lp->l_next; } return (last); } mg-20161005/extend.c010064400017510001751000000526371276555461200127160ustar00hanboetes/* $OpenBSD: extend.c,v 1.64 2016/09/01 21:06:09 lum Exp $ */ /* This file is in the public domain. */ /* * Extended (M-X) commands, rebinding, and startup file processing. */ #include #include #include #include #include #include #include #include #include "chrdef.h" #include "def.h" #include "funmap.h" #include "kbd.h" #include "key.h" #include "macro.h" static int remap(KEYMAP *, int, PF, KEYMAP *); static KEYMAP *reallocmap(KEYMAP *); static void fixmap(KEYMAP *, KEYMAP *, KEYMAP *); static int dobind(KEYMAP *, const char *, int); static char *skipwhite(char *); static char *parsetoken(char *); static int bindkey(KEYMAP **, const char *, KCHAR *, int); /* * Insert a string, mainly for use from macros (created by selfinsert). */ /* ARGSUSED */ int insert(int f, int n) { char buf[128], *bufp, *cp; int count, c; if (inmacro) { while (--n >= 0) { for (count = 0; count < maclcur->l_used; count++) { if ((((c = maclcur->l_text[count]) == '\n') ? lnewline() : linsert(1, c)) != TRUE) return (FALSE); } } maclcur = maclcur->l_fp; return (TRUE); } if (n == 1) /* CFINS means selfinsert can tack on the end */ thisflag |= CFINS; if ((bufp = eread("Insert: ", buf, sizeof(buf), EFNEW)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); while (--n >= 0) { cp = buf; while (*cp) { if (((*cp == '\n') ? lnewline() : linsert(1, *cp)) != TRUE) return (FALSE); cp++; } } return (TRUE); } /* * Bind a key to a function. Cases range from the trivial (replacing an * existing binding) to the extremely complex (creating a new prefix in a * map_element that already has one, so the map_element must be split, * but the keymap doesn't have enough room for another map_element, so * the keymap is reallocated). No attempt is made to reclaim space no * longer used, if this is a problem flags must be added to indicate * malloced versus static storage in both keymaps and map_elements. * Structure assignments would come in real handy, but K&R based compilers * don't have them. Care is taken so running out of memory will leave * the keymap in a usable state. * Parameters are: * curmap: pointer to the map being changed * c: character being changed * funct: function being changed to * pref_map: if funct==NULL, map to bind to or NULL for new */ static int remap(KEYMAP *curmap, int c, PF funct, KEYMAP *pref_map) { int i, n1, n2, nold; KEYMAP *mp, *newmap; PF *pfp; struct map_element *mep; if (ele >= &curmap->map_element[curmap->map_num] || c < ele->k_base) { if (ele > &curmap->map_element[0] && (funct != NULL || (ele - 1)->k_prefmap == NULL)) n1 = c - (ele - 1)->k_num; else n1 = HUGE; if (ele < &curmap->map_element[curmap->map_num] && (funct != NULL || ele->k_prefmap == NULL)) n2 = ele->k_base - c; else n2 = HUGE; if (n1 <= MAPELEDEF && n1 <= n2) { ele--; if ((pfp = calloc(c - ele->k_base + 1, sizeof(PF))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } nold = ele->k_num - ele->k_base + 1; for (i = 0; i < nold; i++) pfp[i] = ele->k_funcp[i]; while (--n1) pfp[i++] = curmap->map_default; pfp[i] = funct; ele->k_num = c; ele->k_funcp = pfp; } else if (n2 <= MAPELEDEF) { if ((pfp = calloc(ele->k_num - c + 1, sizeof(PF))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } nold = ele->k_num - ele->k_base + 1; for (i = 0; i < nold; i++) pfp[i + n2] = ele->k_funcp[i]; while (--n2) pfp[n2] = curmap->map_default; pfp[0] = funct; ele->k_base = c; ele->k_funcp = pfp; } else { if (curmap->map_num >= curmap->map_max) { if ((newmap = reallocmap(curmap)) == NULL) return (FALSE); curmap = newmap; } if ((pfp = malloc(sizeof(PF))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } pfp[0] = funct; for (mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) { mep->k_base = (mep - 1)->k_base; mep->k_num = (mep - 1)->k_num; mep->k_funcp = (mep - 1)->k_funcp; mep->k_prefmap = (mep - 1)->k_prefmap; } ele->k_base = c; ele->k_num = c; ele->k_funcp = pfp; ele->k_prefmap = NULL; curmap->map_num++; } if (funct == NULL) { if (pref_map != NULL) ele->k_prefmap = pref_map; else { if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1) * sizeof(struct map_element))) == NULL) { dobeep(); ewprintf("Out of memory"); ele->k_funcp[c - ele->k_base] = curmap->map_default; return (FALSE); } mp->map_num = 0; mp->map_max = MAPINIT; mp->map_default = rescan; ele->k_prefmap = mp; } } } else { n1 = c - ele->k_base; if (ele->k_funcp[n1] == funct && (funct != NULL || pref_map == NULL || pref_map == ele->k_prefmap)) /* no change */ return (TRUE); if (funct != NULL || ele->k_prefmap == NULL) { if (ele->k_funcp[n1] == NULL) ele->k_prefmap = NULL; /* easy case */ ele->k_funcp[n1] = funct; if (funct == NULL) { if (pref_map != NULL) ele->k_prefmap = pref_map; else { if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1) * sizeof(struct map_element))) == NULL) { dobeep(); ewprintf("Out of memory"); ele->k_funcp[c - ele->k_base] = curmap->map_default; return (FALSE); } mp->map_num = 0; mp->map_max = MAPINIT; mp->map_default = rescan; ele->k_prefmap = mp; } } } else { /* * This case is the splits. * Determine which side of the break c goes on * 0 = after break; 1 = before break */ n2 = 1; for (i = 0; n2 && i < n1; i++) n2 &= ele->k_funcp[i] != NULL; if (curmap->map_num >= curmap->map_max) { if ((newmap = reallocmap(curmap)) == NULL) return (FALSE); curmap = newmap; } if ((pfp = calloc(ele->k_num - c + !n2, sizeof(PF))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } ele->k_funcp[n1] = NULL; for (i = n1 + n2; i <= ele->k_num - ele->k_base; i++) pfp[i - n1 - n2] = ele->k_funcp[i]; for (mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) { mep->k_base = (mep - 1)->k_base; mep->k_num = (mep - 1)->k_num; mep->k_funcp = (mep - 1)->k_funcp; mep->k_prefmap = (mep - 1)->k_prefmap; } ele->k_num = c - !n2; (ele + 1)->k_base = c + n2; (ele + 1)->k_funcp = pfp; ele += !n2; ele->k_prefmap = NULL; curmap->map_num++; if (pref_map == NULL) { if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1) * sizeof(struct map_element))) == NULL) { dobeep(); ewprintf("Out of memory"); ele->k_funcp[c - ele->k_base] = curmap->map_default; return (FALSE); } mp->map_num = 0; mp->map_max = MAPINIT; mp->map_default = rescan; ele->k_prefmap = mp; } else ele->k_prefmap = pref_map; } } return (TRUE); } /* * Reallocate a keymap. Returns NULL (without trashing the current map) * on failure. */ static KEYMAP * reallocmap(KEYMAP *curmap) { struct maps_s *mps; KEYMAP *mp; int i; if (curmap->map_max > SHRT_MAX - MAPGROW) { dobeep(); ewprintf("keymap too large"); return (NULL); } if ((mp = malloc(sizeof(KEYMAP) + (curmap->map_max + (MAPGROW - 1)) * sizeof(struct map_element))) == NULL) { dobeep(); ewprintf("Out of memory"); return (NULL); } mp->map_num = curmap->map_num; mp->map_max = curmap->map_max + MAPGROW; mp->map_default = curmap->map_default; for (i = curmap->map_num; i--;) { mp->map_element[i].k_base = curmap->map_element[i].k_base; mp->map_element[i].k_num = curmap->map_element[i].k_num; mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp; mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap; } for (mps = maps; mps != NULL; mps = mps->p_next) { if (mps->p_map == curmap) mps->p_map = mp; else fixmap(curmap, mp, mps->p_map); } ele = &mp->map_element[ele - &curmap->map_element[0]]; return (mp); } /* * Fix references to a reallocated keymap (recursive). */ static void fixmap(KEYMAP *curmap, KEYMAP *mp, KEYMAP *mt) { int i; for (i = mt->map_num; i--;) { if (mt->map_element[i].k_prefmap != NULL) { if (mt->map_element[i].k_prefmap == curmap) mt->map_element[i].k_prefmap = mp; else fixmap(curmap, mp, mt->map_element[i].k_prefmap); } } } /* * Do the input for local-set-key, global-set-key and define-key * then call remap to do the work. */ static int dobind(KEYMAP *curmap, const char *p, int unbind) { KEYMAP *pref_map = NULL; PF funct; char bprompt[80], *bufp, *pep; int c, s, n; if (macrodef) { /* * Keystrokes aren't collected. Not hard, but pretty useless. * Would not work for function keys in any case. */ dobeep(); ewprintf("Can't rebind key in macro"); return (FALSE); } if (inmacro) { for (s = 0; s < maclcur->l_used - 1; s++) { if (doscan(curmap, c = CHARMASK(maclcur->l_text[s]), &curmap) != NULL) { if (remap(curmap, c, NULL, NULL) != TRUE) return (FALSE); } } (void)doscan(curmap, c = maclcur->l_text[s], NULL); maclcur = maclcur->l_fp; } else { n = strlcpy(bprompt, p, sizeof(bprompt)); if (n >= sizeof(bprompt)) n = sizeof(bprompt) - 1; pep = bprompt + n; for (;;) { ewprintf("%s", bprompt); pep[-1] = ' '; pep = getkeyname(pep, sizeof(bprompt) - (pep - bprompt), c = getkey(FALSE)); if (doscan(curmap, c, &curmap) != NULL) break; *pep++ = '-'; *pep = '\0'; } } if (unbind) funct = rescan; else { if ((bufp = eread("%s to command: ", bprompt, sizeof(bprompt), EFFUNC | EFNEW, bprompt)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if (((funct = name_function(bprompt)) == NULL) ? (pref_map = name_map(bprompt)) == NULL : funct == NULL) { dobeep(); ewprintf("[No match]"); return (FALSE); } } return (remap(curmap, c, funct, pref_map)); } /* * bindkey: bind key sequence to a function in the specified map. Used by * excline so it can bind function keys. To close to release to change * calling sequence, should just pass KEYMAP *curmap rather than * KEYMAP **mapp. */ static int bindkey(KEYMAP **mapp, const char *fname, KCHAR *keys, int kcount) { KEYMAP *curmap = *mapp; KEYMAP *pref_map = NULL; PF funct; int c; if (fname == NULL) funct = rescan; else if (((funct = name_function(fname)) == NULL) ? (pref_map = name_map(fname)) == NULL : funct == NULL) { dobeep(); ewprintf("[No match: %s]", fname); return (FALSE); } while (--kcount) { if (doscan(curmap, c = *keys++, &curmap) != NULL) { if (remap(curmap, c, NULL, NULL) != TRUE) return (FALSE); /* * XXX - Bizzarreness. remap creates an empty KEYMAP * that the last key is supposed to point to. */ curmap = ele->k_prefmap; } } (void)doscan(curmap, c = *keys, NULL); return (remap(curmap, c, funct, pref_map)); } /* * Wrapper for bindkey() that converts escapes. */ int dobindkey(KEYMAP *map, const char *func, const char *str) { int i; for (i = 0; *str && i < MAXKEY; i++) { /* XXX - convert numbers w/ strol()? */ if (*str == '^' && *(str + 1) != '\0') { key.k_chars[i] = CCHR(toupper((unsigned char)*++str)); } else if (*str == '\\' && *(str + 1) != '\0') { switch (*++str) { case '^': key.k_chars[i] = '^'; break; case 't': case 'T': key.k_chars[i] = '\t'; break; case 'n': case 'N': key.k_chars[i] = '\n'; break; case 'r': case 'R': key.k_chars[i] = '\r'; break; case 'e': case 'E': key.k_chars[i] = CCHR('['); break; case '\\': key.k_chars[i] = '\\'; break; } } else key.k_chars[i] = *str; str++; } key.k_count = i; return (bindkey(&map, func, key.k_chars, key.k_count)); } /* * This function modifies the fundamental keyboard map. */ /* ARGSUSED */ int bindtokey(int f, int n) { return (dobind(fundamental_map, "Global set key: ", FALSE)); } /* * This function modifies the current mode's keyboard map. */ /* ARGSUSED */ int localbind(int f, int n) { return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local set key: ", FALSE)); } /* * This function redefines a key in any keymap. */ /* ARGSUSED */ int redefine_key(int f, int n) { static char buf[48]; char tmp[32], *bufp; KEYMAP *mp; (void)strlcpy(buf, "Define key map: ", sizeof(buf)); if ((bufp = eread("%s", tmp, sizeof(tmp), EFNEW, buf)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); (void)strlcat(buf, tmp, sizeof(buf)); if ((mp = name_map(tmp)) == NULL) { dobeep(); ewprintf("Unknown map %s", tmp); return (FALSE); } if (strlcat(buf, "key: ", sizeof(buf)) >= sizeof(buf)) return (FALSE); return (dobind(mp, buf, FALSE)); } /* ARGSUSED */ int unbindtokey(int f, int n) { return (dobind(fundamental_map, "Global unset key: ", TRUE)); } /* ARGSUSED */ int localunbind(int f, int n) { return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local unset key: ", TRUE)); } /* * Extended command. Call the message line routine to read in the command * name and apply autocompletion to it. When it comes back, look the name * up in the symbol table and run the command if it is found. Print an * error if there is anything wrong. */ int extend(int f, int n) { PF funct; char xname[NXNAME], *bufp; if (!(f & FFARG)) bufp = eread("M-x ", xname, NXNAME, EFNEW | EFFUNC); else bufp = eread("%d M-x ", xname, NXNAME, EFNEW | EFFUNC, n); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if ((funct = name_function(bufp)) != NULL) { if (macrodef) { struct line *lp = maclcur; macro[macrocount - 1].m_funct = funct; maclcur = lp->l_bp; maclcur->l_fp = lp->l_fp; free(lp); } return ((*funct)(f, n)); } dobeep(); ewprintf("[No match]"); return (FALSE); } /* * Define the commands needed to do startup-file processing. * This code is mostly a kludge just so we can get startup-file processing. * * If you're serious about having this code, you should rewrite it. * To wit: * It has lots of funny things in it to make the startup-file look * like a GNU startup file; mostly dealing with parens and semicolons. * This should all vanish. * * We define eval-expression because it's easy. It can make * *-set-key or define-key set an arbitrary key sequence, so it isn't * useless. */ /* * evalexpr - get one line from the user, and run it. */ /* ARGSUSED */ int evalexpr(int f, int n) { char exbuf[128], *bufp; if ((bufp = eread("Eval: ", exbuf, sizeof(exbuf), EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); return (excline(exbuf)); } /* * evalbuffer - evaluate the current buffer as line commands. Useful for * testing startup files. */ /* ARGSUSED */ int evalbuffer(int f, int n) { struct line *lp; struct buffer *bp = curbp; int s; static char excbuf[128]; for (lp = bfirstlp(bp); lp != bp->b_headp; lp = lforw(lp)) { if (llength(lp) >= 128) return (FALSE); (void)strncpy(excbuf, ltext(lp), llength(lp)); /* make sure it's terminated */ excbuf[llength(lp)] = '\0'; if ((s = excline(excbuf)) != TRUE) return (s); } return (TRUE); } /* * evalfile - go get a file and evaluate it as line commands. You can * go get your own startup file if need be. */ /* ARGSUSED */ int evalfile(int f, int n) { char fname[NFILEN], *bufp; if ((bufp = eread("Load file: ", fname, NFILEN, EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); return (load(fname)); } /* * load - go load the file name we got passed. */ int load(const char *fname) { int s = TRUE, line, ret; int nbytes = 0; char excbuf[128]; FILE *ffp; if ((fname = adjustname(fname, TRUE)) == NULL) /* just to be careful */ return (FALSE); ret = ffropen(&ffp, fname, NULL); if (ret != FIOSUC) { if (ret == FIODIR) (void)ffclose(ffp, NULL); return (FALSE); } line = 0; while ((s = ffgetline(ffp, excbuf, sizeof(excbuf) - 1, &nbytes)) == FIOSUC) { line++; excbuf[nbytes] = '\0'; if (excline(excbuf) != TRUE) { s = FIOERR; dobeep(); ewprintf("Error loading file %s at line %d", fname, line); break; } } (void)ffclose(ffp, NULL); excbuf[nbytes] = '\0'; if (s != FIOEOF || (nbytes && excline(excbuf) != TRUE)) return (FALSE); return (TRUE); } /* * excline - run a line from a load file or eval-expression. */ int excline(char *line) { PF fp; struct line *lp, *np; int status, c, f, n; char *funcp, *tmp; char *argp = NULL; long nl; int bind; KEYMAP *curmap; #define BINDARG 0 /* this arg is key to bind (local/global set key) */ #define BINDNO 1 /* not binding or non-quoted BINDARG */ #define BINDNEXT 2 /* next arg " (define-key) */ #define BINDDO 3 /* already found key to bind */ #define BINDEXT 1 /* space for trailing \0 */ lp = NULL; if (macrodef || inmacro) { dobeep(); ewprintf("Not now!"); return (FALSE); } f = 0; n = 1; funcp = skipwhite(line); if (*funcp == '\0') return (TRUE); /* No error on blank lines */ line = parsetoken(funcp); if (*line != '\0') { *line++ = '\0'; line = skipwhite(line); if (ISDIGIT(*line) || *line == '-') { argp = line; line = parsetoken(line); } } if (argp != NULL) { f = FFARG; nl = strtol(argp, &tmp, 10); if (*tmp != '\0') return (FALSE); if (nl >= INT_MAX || nl <= INT_MIN) return (FALSE); n = (int)nl; } if ((fp = name_function(funcp)) == NULL) { dobeep(); ewprintf("Unknown function: %s", funcp); return (FALSE); } if (fp == bindtokey || fp == unbindtokey) { bind = BINDARG; curmap = fundamental_map; } else if (fp == localbind || fp == localunbind) { bind = BINDARG; curmap = curbp->b_modes[curbp->b_nmodes]->p_map; } else if (fp == redefine_key) bind = BINDNEXT; else bind = BINDNO; /* Pack away all the args now... */ if ((np = lalloc(0)) == FALSE) return (FALSE); np->l_fp = np->l_bp = maclcur = np; while (*line != '\0') { argp = skipwhite(line); if (*argp == '\0') break; line = parsetoken(argp); if (*argp != '"') { if (*argp == '\'') ++argp; if ((lp = lalloc((int) (line - argp) + BINDEXT)) == NULL) { status = FALSE; goto cleanup; } bcopy(argp, ltext(lp), (int)(line - argp)); /* don't count BINDEXT */ lp->l_used--; if (bind == BINDARG) bind = BINDNO; } else { /* quoted strings are special */ ++argp; if (bind != BINDARG) { lp = lalloc((int)(line - argp) + BINDEXT); if (lp == NULL) { status = FALSE; goto cleanup; } lp->l_used = 0; } else key.k_count = 0; while (*argp != '"' && *argp != '\0') { if (*argp != '\\') c = *argp++; else { switch (*++argp) { case 't': case 'T': c = CCHR('I'); break; case 'n': case 'N': c = CCHR('J'); break; case 'r': case 'R': c = CCHR('M'); break; case 'e': case 'E': c = CCHR('['); break; case '^': /* * split into two statements * due to bug in OSK cpp */ c = CHARMASK(*++argp); c = ISLOWER(c) ? CCHR(TOUPPER(c)) : CCHR(c); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': c = *argp - '0'; if (argp[1] <= '7' && argp[1] >= '0') { c <<= 3; c += *++argp - '0'; if (argp[1] <= '7' && argp[1] >= '0') { c <<= 3; c += *++argp - '0'; } } break; case 'f': case 'F': c = *++argp - '0'; if (ISDIGIT(argp[1])) { c *= 10; c += *++argp - '0'; } c += KFIRST; break; default: c = CHARMASK(*argp); break; } argp++; } if (bind == BINDARG) key.k_chars[key.k_count++] = c; else lp->l_text[lp->l_used++] = c; } if (*line) line++; } switch (bind) { case BINDARG: bind = BINDDO; break; case BINDNEXT: lp->l_text[lp->l_used] = '\0'; if ((curmap = name_map(lp->l_text)) == NULL) { dobeep(); ewprintf("No such mode: %s", lp->l_text); status = FALSE; free(lp); goto cleanup; } free(lp); bind = BINDARG; break; default: lp->l_fp = np->l_fp; lp->l_bp = np; np->l_fp = lp; np = lp; } } switch (bind) { default: dobeep(); ewprintf("Bad args to set key"); status = FALSE; break; case BINDDO: if (fp != unbindtokey && fp != localunbind) { lp->l_text[lp->l_used] = '\0'; status = bindkey(&curmap, lp->l_text, key.k_chars, key.k_count); } else status = bindkey(&curmap, NULL, key.k_chars, key.k_count); break; case BINDNO: inmacro = TRUE; maclcur = maclcur->l_fp; status = (*fp)(f, n); inmacro = FALSE; } cleanup: lp = maclcur->l_fp; while (lp != maclcur) { np = lp->l_fp; free(lp); lp = np; } free(lp); maclhead = NULL; macrodef = FALSE; return (status); } /* * a pair of utility functions for the above */ static char * skipwhite(char *s) { while (*s == ' ' || *s == '\t' || *s == ')' || *s == '(') s++; if ((*s == ';') || (*s == '#')) *s = '\0'; return (s); } static char * parsetoken(char *s) { if (*s != '"') { while (*s && *s != ' ' && *s != '\t' && *s != ')' && *s != '(') s++; if (*s == ';') *s = '\0'; } else do { /* * Strings get special treatment. * Beware: You can \ out the end of the string! */ if (*s == '\\') ++s; } while (*++s != '"' && *s != '\0'); return (s); } mg-20161005/file.c010064400017510001751000000447351276204442100123330ustar00hanboetes/* $OpenBSD: file.c,v 1.100 2016/01/02 10:39:19 lum Exp $ */ /* This file is in the public domain. */ /* * File commands. */ #include #include #include #include #include #include #include #include #include #include "def.h" size_t xdirname(char *, const char *, size_t); /* * Insert a file into the current buffer. Real easy - just call the * insertfile routine with the file name. */ /* ARGSUSED */ int fileinsert(int f, int n) { char fname[NFILEN], *bufp, *adjf; if (getbufcwd(fname, sizeof(fname)) != TRUE) fname[0] = '\0'; bufp = eread("Insert file: ", fname, NFILEN, EFNEW | EFCR | EFFILE | EFDEF); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); adjf = adjustname(bufp, TRUE); if (adjf == NULL) return (FALSE); return (insertfile(adjf, NULL, FALSE)); } /* * Select a file for editing. If the file is a directory, invoke dired. * Otherwise, look around to see if you can find the file in another buffer; * if you can find it, just switch to the buffer. If you cannot find the * file, create a new buffer, read in the text, and switch to the new buffer. */ /* ARGSUSED */ int filevisit(int f, int n) { struct buffer *bp; char fname[NFILEN], *bufp, *adjf; int status; if (getbufcwd(fname, sizeof(fname)) != TRUE) fname[0] = '\0'; bufp = eread("Find file: ", fname, NFILEN, EFNEW | EFCR | EFFILE | EFDEF); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); adjf = adjustname(fname, TRUE); if (adjf == NULL) return (FALSE); if (fisdir(adjf) == TRUE) return (do_dired(adjf)); if ((bp = findbuffer(adjf)) == NULL) return (FALSE); curbp = bp; if (showbuffer(bp, curwp, WFFULL) != TRUE) return (FALSE); if (bp->b_fname[0] == '\0') { if ((status = readin(adjf)) != TRUE) killbuffer(bp); return (status); } return (TRUE); } /* * Replace the current file with an alternate one. Semantics for finding * the replacement file are the same as 'filevisit', except the current * buffer is killed before the switch. If the kill fails, or is aborted, * revert to the original file. */ /* ARGSUSED */ int filevisitalt(int f, int n) { char fname[NFILEN], *bufp; if (getbufcwd(fname, sizeof(fname)) != TRUE) fname[0] = '\0'; bufp = eread("Find alternate file: ", fname, NFILEN, EFNEW | EFCR | EFFILE | EFDEF); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); return (do_filevisitalt(fname)); } int do_filevisitalt(char *fn) { struct buffer *bp; int status; char *adjf; status = killbuffer(curbp); if (status == ABORT || status == FALSE) return (ABORT); adjf = adjustname(fn, TRUE); if (adjf == NULL) return (FALSE); if (fisdir(adjf) == TRUE) return (do_dired(adjf)); if ((bp = findbuffer(adjf)) == NULL) return (FALSE); curbp = bp; if (showbuffer(bp, curwp, WFFULL) != TRUE) return (FALSE); if (bp->b_fname[0] == '\0') { if ((status = readin(adjf)) != TRUE) killbuffer(bp); return (status); } return (TRUE); } int filevisitro(int f, int n) { int error; error = filevisit(f, n); if (error != TRUE) return (error); curbp->b_flag |= BFREADONLY; return (TRUE); } /* * Pop to a file in the other window. Same as the last function, but uses * popbuf instead of showbuffer. */ /* ARGSUSED */ int poptofile(int f, int n) { struct buffer *bp; struct mgwin *wp; char fname[NFILEN], *adjf, *bufp; int status; if (getbufcwd(fname, sizeof(fname)) != TRUE) fname[0] = '\0'; if ((bufp = eread("Find file in other window: ", fname, NFILEN, EFNEW | EFCR | EFFILE | EFDEF)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); adjf = adjustname(fname, TRUE); if (adjf == NULL) return (FALSE); if (fisdir(adjf) == TRUE) return (do_dired(adjf)); if ((bp = findbuffer(adjf)) == NULL) return (FALSE); if (bp == curbp) return (splitwind(f, n)); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; curwp = wp; if (bp->b_fname[0] == '\0') { if ((status = readin(adjf)) != TRUE) killbuffer(bp); return (status); } return (TRUE); } /* * Read the file "fname" into the current buffer. Make all of the text * in the buffer go away, after checking for unsaved changes. This is * called by the "read" command, the "visit" command, and the mainline * (for "mg file"). */ int readin(char *fname) { struct mgwin *wp; struct stat statbuf; int status, i, ro = FALSE; PF *ael; char dp[NFILEN]; /* might be old */ if (bclear(curbp) != TRUE) return (TRUE); /* Clear readonly. May be set by autoexec path */ curbp->b_flag &= ~BFREADONLY; if ((status = insertfile(fname, fname, TRUE)) != TRUE) { dobeep(); ewprintf("File is not readable: %s", fname); return (FALSE); } for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { wp->w_dotp = wp->w_linep = bfirstlp(curbp); wp->w_doto = 0; wp->w_markp = NULL; wp->w_marko = 0; } } /* * Call auto-executing function if we need to. */ if ((ael = find_autoexec(fname)) != NULL) { for (i = 0; ael[i] != NULL; i++) (*ael[i])(0, 1); free(ael); } /* no change */ curbp->b_flag &= ~BFCHG; /* * Set the buffer READONLY flag if any of following are true: * 1. file is a directory. * 2. file is read-only. * 3. file doesn't exist and directory is read-only. */ if (fisdir(fname) == TRUE) { ro = TRUE; } else if ((access(fname, W_OK) == -1)) { if (errno != ENOENT) { ro = TRUE; } else if (errno == ENOENT) { (void)xdirname(dp, fname, sizeof(dp)); (void)strlcat(dp, "/", sizeof(dp)); /* Missing directory; keep buffer rw, like emacs */ if (stat(dp, &statbuf) == -1 && errno == ENOENT) { if (eyorn("Missing directory, create") == TRUE) (void)do_makedir(dp); } else if (access(dp, W_OK) == -1 && errno == EACCES) { ewprintf("File not found and directory" " write-protected"); ro = TRUE; } } } if (ro == TRUE) curbp->b_flag |= BFREADONLY; if (startrow) { gotoline(FFARG, startrow); startrow = 0; } undo_add_modified(); return (status); } /* * NB, getting file attributes is done here under control of a flag * rather than in readin, which would be cleaner. I was concerned * that some operating system might require the file to be open * in order to get the information. Similarly for writing. */ /* * Insert a file in the current buffer, after dot. If file is a directory, * and 'replacebuf' is TRUE, invoke dired mode, else die with an error. * If file is a regular file, set mark at the end of the text inserted; * point at the beginning. Return a standard status. Print a summary * (lines read, error message) out as well. This routine also does the * read end of backup processing. The BFBAK flag, if set in a buffer, * says that a backup should be taken. It is set when a file is read in, * but not on a new file. You don't need to make a backup copy of nothing. */ static char *line = NULL; static int linesize = 0; int insertfile(char *fname, char *newname, int replacebuf) { struct buffer *bp; struct line *lp1, *lp2; struct line *olp; /* line we started at */ struct mgwin *wp; int nbytes, s, nline = 0, siz, x, x2; int opos; /* offset we started at */ int oline; /* original line number */ FILE *ffp; if (replacebuf == TRUE) x = undo_enable(FFRAND, 0); else x = undo_enabled(); lp1 = NULL; if (line == NULL) { line = malloc(NLINE); if (line == NULL) panic("out of memory"); linesize = NLINE; } /* cheap */ bp = curbp; if (newname != NULL) { (void)strlcpy(bp->b_fname, newname, sizeof(bp->b_fname)); (void)xdirname(bp->b_cwd, newname, sizeof(bp->b_cwd)); (void)strlcat(bp->b_cwd, "/", sizeof(bp->b_cwd)); } /* hard file open */ if ((s = ffropen(&ffp, fname, (replacebuf == TRUE) ? bp : NULL)) == FIOERR) goto out; if (s == FIOFNF) { /* file not found */ if (newname != NULL) ewprintf("(New file)"); else ewprintf("(File not found)"); goto out; } else if (s == FIODIR) { /* file was a directory */ if (replacebuf == FALSE) { dobeep(); ewprintf("Cannot insert: file is a directory, %s", fname); goto cleanup; } killbuffer(bp); bp = dired_(fname); undo_enable(FFRAND, x); if (bp == NULL) return (FALSE); curbp = bp; return (showbuffer(bp, curwp, WFFULL | WFMODE)); } else { (void)xdirname(bp->b_cwd, fname, sizeof(bp->b_cwd)); (void)strlcat(bp->b_cwd, "/", sizeof(bp->b_cwd)); } opos = curwp->w_doto; oline = curwp->w_dotline; /* * Open a new line at dot and start inserting after it. * We will delete this newline after insertion. * Disable undo, as we create the undo record manually. */ x2 = undo_enable(FFRAND, 0); (void)lnewline(); olp = lback(curwp->w_dotp); undo_enable(FFRAND, x2); nline = 0; siz = 0; while ((s = ffgetline(ffp, line, linesize, &nbytes)) != FIOERR) { retry: siz += nbytes + 1; switch (s) { case FIOSUC: /* FALLTHRU */ case FIOEOF: ++nline; if ((lp1 = lalloc(nbytes)) == NULL) { /* keep message on the display */ s = FIOERR; undo_add_insert(olp, opos, siz - nbytes - 1 - 1); goto endoffile; } bcopy(line, <ext(lp1)[0], nbytes); lp2 = lback(curwp->w_dotp); lp2->l_fp = lp1; lp1->l_fp = curwp->w_dotp; lp1->l_bp = lp2; curwp->w_dotp->l_bp = lp1; if (s == FIOEOF) { undo_add_insert(olp, opos, siz - 1); goto endoffile; } break; case FIOLONG: { /* a line too long to fit in our buffer */ char *cp; int newsize; newsize = linesize * 2; if (newsize < 0 || (cp = malloc(newsize)) == NULL) { dobeep(); ewprintf("Could not allocate %d bytes", newsize); s = FIOERR; goto endoffile; } bcopy(line, cp, linesize); free(line); line = cp; s = ffgetline(ffp, line + linesize, linesize, &nbytes); nbytes += linesize; linesize = newsize; if (s == FIOERR) goto endoffile; goto retry; } default: dobeep(); ewprintf("Unknown code %d reading file", s); s = FIOERR; break; } } endoffile: /* ignore errors */ (void)ffclose(ffp, NULL); /* don't zap an error */ if (s == FIOEOF) { if (nline == 1) ewprintf("(Read 1 line)"); else ewprintf("(Read %d lines)", nline); } /* set mark at the end of the text */ curwp->w_dotp = curwp->w_markp = lback(curwp->w_dotp); curwp->w_marko = llength(curwp->w_markp); curwp->w_markline = oline + nline + 1; /* * if we are at the end of the file, ldelnewline is a no-op, * but we still need to decrement the line and markline counts * as we've accounted for this fencepost in our arithmetic */ if (lforw(curwp->w_dotp) == curwp->w_bufp->b_headp) { curwp->w_bufp->b_lines--; curwp->w_markline--; } else (void)ldelnewline(); curwp->w_dotp = olp; curwp->w_doto = opos; curwp->w_dotline = oline; if (olp == curbp->b_headp) curwp->w_dotp = lforw(olp); if (newname != NULL) bp->b_flag |= BFCHG | BFBAK; /* Need a backup. */ else bp->b_flag |= BFCHG; /* * If the insert was at the end of buffer, set lp1 to the end of * buffer line, and lp2 to the beginning of the newly inserted text. * (Otherwise lp2 is set to NULL.) This is used below to set * pointers in other windows correctly if they are also at the end of * buffer. */ lp1 = bp->b_headp; if (curwp->w_markp == lp1) { lp2 = curwp->w_dotp; } else { /* delete extraneous newline */ (void)ldelnewline(); out: lp2 = NULL; } for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { wp->w_rflag |= WFMODE | WFEDIT; if (wp != curwp && lp2 != NULL) { if (wp->w_dotp == lp1) wp->w_dotp = lp2; if (wp->w_markp == lp1) wp->w_markp = lp2; if (wp->w_linep == lp1) wp->w_linep = lp2; } } } bp->b_lines += nline; cleanup: undo_enable(FFRAND, x); /* return FALSE if error */ return (s != FIOERR); } /* * Ask for a file name and write the contents of the current buffer to that * file. Update the remembered file name and clear the buffer changed flag. * This handling of file names is different from the earlier versions and * is more compatible with Gosling EMACS than with ITS EMACS. */ /* ARGSUSED */ int filewrite(int f, int n) { struct stat statbuf; int s; char fname[NFILEN], bn[NBUFN], tmp[NFILEN + 25]; char *adjfname, *bufp; FILE *ffp; if (getbufcwd(fname, sizeof(fname)) != TRUE) fname[0] = '\0'; if ((bufp = eread("Write file: ", fname, NFILEN, EFDEF | EFNEW | EFCR | EFFILE)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); adjfname = adjustname(fname, TRUE); if (adjfname == NULL) return (FALSE); /* Check if file exists; write checks done later */ if (stat(adjfname, &statbuf) == 0) { if (S_ISDIR(statbuf.st_mode)) { dobeep(); ewprintf("%s is a directory", adjfname); return (FALSE); } snprintf(tmp, sizeof(tmp), "File `%s' exists; overwrite", adjfname); if ((s = eyorn(tmp)) != TRUE) return (s); } /* old attributes are no longer current */ bzero(&curbp->b_fi, sizeof(curbp->b_fi)); if ((s = writeout(&ffp, curbp, adjfname)) == TRUE) { (void)strlcpy(curbp->b_fname, adjfname, sizeof(curbp->b_fname)); if (getbufcwd(curbp->b_cwd, sizeof(curbp->b_cwd)) != TRUE) (void)strlcpy(curbp->b_cwd, "/", sizeof(curbp->b_cwd)); if (augbname(bn, curbp->b_fname, sizeof(bn)) == FALSE) return (FALSE); free(curbp->b_bname); if ((curbp->b_bname = strdup(bn)) == NULL) return (FALSE); (void)fupdstat(curbp); curbp->b_flag &= ~(BFBAK | BFCHG); upmodes(curbp); undo_add_boundary(FFRAND, 1); undo_add_modified(); } return (s); } /* * Save the contents of the current buffer back into its associated file. */ static int makebackup = TRUE; /* ARGSUSED */ int filesave(int f, int n) { if (curbp->b_fname[0] == '\0') return (filewrite(f, n)); else return (buffsave(curbp)); } /* * Save the contents of the buffer argument into its associated file. Do * nothing if there have been no changes (is this a bug, or a feature?). * Error if there is no remembered file name. If this is the first write * since the read or visit, then a backup copy of the file is made. * Allow user to select whether or not to make backup files by looking at * the value of makebackup. */ int buffsave(struct buffer *bp) { int s; FILE *ffp; /* return, no changes */ if ((bp->b_flag & BFCHG) == 0) { ewprintf("(No changes need to be saved)"); return (TRUE); } /* must have a name */ if (bp->b_fname[0] == '\0') { dobeep(); ewprintf("No file name"); return (FALSE); } /* Ensure file has not been modified elsewhere */ /* We don't use the ignore flag here */ if (fchecktime(bp) != TRUE) { if ((s = eyesno("File has changed on disk since last save. " "Save anyway")) != TRUE) return (s); } if (makebackup && (bp->b_flag & BFBAK)) { s = fbackupfile(bp->b_fname); /* hard error */ if (s == ABORT) return (FALSE); /* softer error */ if (s == FALSE && (s = eyesno("Backup error, save anyway")) != TRUE) return (s); } if ((s = writeout(&ffp, bp, bp->b_fname)) == TRUE) { (void)fupdstat(bp); bp->b_flag &= ~(BFCHG | BFBAK); upmodes(bp); undo_add_boundary(FFRAND, 1); undo_add_modified(); } return (s); } /* * Since we don't have variables (we probably should) this is a command * processor for changing the value of the make backup flag. If no argument * is given, sets makebackup to true, so backups are made. If an argument is * given, no backup files are made when saving a new version of a file. */ /* ARGSUSED */ int makebkfile(int f, int n) { if (f & FFARG) makebackup = n > 0; else makebackup = !makebackup; ewprintf("Backup files %sabled", makebackup ? "en" : "dis"); return (TRUE); } /* * NB: bp is passed to both ffwopen and ffclose because some * attribute information may need to be updated at open time * and others after the close. This is OS-dependent. Note * that the ff routines are assumed to be able to tell whether * the attribute information has been set up in this buffer * or not. */ /* * This function performs the details of file writing; writing the file * in buffer bp to file fn. Uses the file management routines in the * "fileio.c" package. Most of the grief is checking of some sort. * You may want to call fupdstat() after using this function. */ int writeout(FILE ** ffp, struct buffer *bp, char *fn) { struct stat statbuf; int s; char dp[NFILEN]; if (stat(fn, &statbuf) == -1 && errno == ENOENT) { errno = 0; (void)xdirname(dp, fn, sizeof(dp)); (void)strlcat(dp, "/", sizeof(dp)); if (access(dp, W_OK) && errno == EACCES) { dobeep(); ewprintf("Directory %s write-protected", dp); return (FIOERR); } else if (errno == ENOENT) { dobeep(); ewprintf("%s: no such directory", dp); return (FIOERR); } } /* open writes message */ if ((s = ffwopen(ffp, fn, bp)) != FIOSUC) return (FALSE); s = ffputbuf(*ffp, bp); if (s == FIOSUC) { /* no write error */ s = ffclose(*ffp, bp); if (s == FIOSUC) ewprintf("Wrote %s", fn); } else { /* print a message indicating write error */ (void)ffclose(*ffp, bp); dobeep(); ewprintf("Unable to write %s", fn); } return (s == FIOSUC); } /* * Tag all windows for bp (all windows if bp == NULL) as needing their * mode line updated. */ void upmodes(struct buffer *bp) { struct mgwin *wp; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) if (bp == NULL || curwp->w_bufp == bp) wp->w_rflag |= WFMODE; } /* * dirname using strlcpy semantic. * Like dirname() except an empty string is returned in * place of "/". This means we can always add a trailing * slash and be correct. * Address portability issues by copying argument * before using. Some implementations modify the input string. */ size_t xdirname(char *dp, const char *path, size_t dplen) { char ts[NFILEN]; size_t len; (void)strlcpy(ts, path, NFILEN); len = strlcpy(dp, dirname(ts), dplen); if (dplen > 0 && dp[0] == '/' && dp[1] == '\0') { dp[0] = '\0'; len = 0; } return (len); } /* * basename using strlcpy/strlcat semantic. * Address portability issue by copying argument * before using: some implementations modify the input string. */ size_t xbasename(char *bp, const char *path, size_t bplen) { char ts[NFILEN]; (void)strlcpy(ts, path, NFILEN); return (strlcpy(bp, basename(ts), bplen)); } /* * The adjusted file name refers to a directory, so open dired mode. */ int do_dired(char *adjf) { struct buffer *bp; if ((bp = dired_(adjf)) == FALSE) return (FALSE); curbp = bp; return (showbuffer(bp, curwp, WFFULL | WFMODE)); } mg-20161005/fileio.c010064400017510001751000000403401276204466300126570ustar00hanboetes/* $OpenBSD: fileio.c,v 1.103 2016/07/28 21:40:25 tedu Exp $ */ /* This file is in the public domain. */ /* * POSIX fileio.c */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "def.h" #include "kbd.h" #include "pathnames.h" static char *bkuplocation(const char *); static int bkupleavetmp(const char *); static char *bkupdir; static int leavetmp = 0; /* 1 = leave any '~' files in tmp dir */ /* * Open a file for reading. */ int ffropen(FILE ** ffp, const char *fn, struct buffer *bp) { if ((*ffp = fopen(fn, "r")) == NULL) { if (errno == ENOENT) return (FIOFNF); return (FIOERR); } /* If 'fn' is a directory open it with dired. */ if (fisdir(fn) == TRUE) return (FIODIR); ffstat(*ffp, bp); return (FIOSUC); } /* * Update stat/dirty info */ void ffstat(FILE *ffp, struct buffer *bp) { struct stat sb; if (bp && fstat(fileno(ffp), &sb) == 0) { /* set highorder bit to make sure this isn't all zero */ bp->b_fi.fi_mode = sb.st_mode | 0x8000; bp->b_fi.fi_uid = sb.st_uid; bp->b_fi.fi_gid = sb.st_gid; /* bp->b_fi.fi_mtime = sb.st_mtimespec; */ bp->b_fi.fi_mtime.tv_sec = sb.st_mtime; bp->b_fi.fi_mtime.tv_nsec = 0; /* Clear the ignore flag */ bp->b_flag &= ~(BFIGNDIRTY | BFDIRTY); } } /* * Update the status/dirty info. If there is an error, * there's not a lot we can do. */ int fupdstat(struct buffer *bp) { FILE *ffp; if ((ffp = fopen(bp->b_fname, "r")) == NULL) { if (errno == ENOENT) return (FIOFNF); return (FIOERR); } ffstat(ffp, bp); (void)ffclose(ffp, bp); return (FIOSUC); } /* * Open a file for writing. */ int ffwopen(FILE ** ffp, const char *fn, struct buffer *bp) { int fd; mode_t fmode = DEFFILEMODE; if (bp && bp->b_fi.fi_mode) fmode = bp->b_fi.fi_mode & 07777; fd = open(fn, O_RDWR | O_CREAT | O_TRUNC, fmode); if (fd == -1) { ffp = NULL; dobeep(); ewprintf("Cannot open file for writing : %s", strerror(errno)); return (FIOERR); } if ((*ffp = fdopen(fd, "w")) == NULL) { dobeep(); ewprintf("Cannot open file for writing : %s", strerror(errno)); close(fd); return (FIOERR); } /* * If we have file information, use it. We don't bother to check for * errors, because there's no a lot we can do about it. Certainly * trying to change ownership will fail if we aren't root. That's * probably OK. If we don't have info, no need to get it, since any * future writes will do the same thing. */ if (bp && bp->b_fi.fi_mode) { fchmod(fd, bp->b_fi.fi_mode & 07777); fchown(fd, bp->b_fi.fi_uid, bp->b_fi.fi_gid); } return (FIOSUC); } /* * Close a file. */ /* ARGSUSED */ int ffclose(FILE *ffp, struct buffer *bp) { if (fclose(ffp) == 0) return (FIOSUC); return (FIOERR); } /* * Write a buffer to the already opened file. bp points to the * buffer. Return the status. */ int ffputbuf(FILE *ffp, struct buffer *bp) { struct line *lp, *lpend; lpend = bp->b_headp; for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) { if (fwrite(ltext(lp), 1, llength(lp), ffp) != llength(lp)) { dobeep(); ewprintf("Write I/O error"); return (FIOERR); } if (lforw(lp) != lpend) /* no implied \n on last line */ putc('\n', ffp); } /* * XXX should be variable controlled (once we have variables) */ if (llength(lback(lpend)) != 0) { if (eyorn("No newline at end of file, add one") == TRUE) { lnewline_at(lback(lpend), llength(lback(lpend))); putc('\n', ffp); } } return (FIOSUC); } /* * Read a line from a file, and store the bytes * in the supplied buffer. Stop on end of file or end of * line. When FIOEOF is returned, there is a valid line * of data without the normally implied \n. * If the line length exceeds nbuf, FIOLONG is returned. */ int ffgetline(FILE *ffp, char *buf, int nbuf, int *nbytes) { int c, i; i = 0; while ((c = getc(ffp)) != EOF && c != '\n') { buf[i++] = c; if (i >= nbuf) return (FIOLONG); } if (c == EOF && ferror(ffp) != FALSE) { dobeep(); ewprintf("File read error"); return (FIOERR); } *nbytes = i; return (c == EOF ? FIOEOF : FIOSUC); } /* * Make a backup copy of "fname". On Unix the backup has the same * name as the original file, with a "~" on the end; this seems to * be newest of the new-speak. The error handling is all in "file.c". * We do a copy instead of a rename since otherwise another process * with an open fd will get the backup, not the new file. This is * a problem when using mg with things like crontab and vipw. */ int fbackupfile(const char *fn) { struct stat sb; int from, to, serrno; ssize_t nread; char buf[BUFSIZ]; char *nname, *tname, *bkpth; if (stat(fn, &sb) == -1) { dobeep(); ewprintf("Can't stat %s : %s", fn, strerror(errno)); return (FALSE); } if ((bkpth = bkuplocation(fn)) == NULL) return (FALSE); if (asprintf(&nname, "%s~", bkpth) == -1) { dobeep(); ewprintf("Can't allocate backup file name : %s", strerror(errno)); free(bkpth); return (ABORT); } if (asprintf(&tname, "%s.XXXXXXXXXX", bkpth) == -1) { dobeep(); ewprintf("Can't allocate temp file name : %s", strerror(errno)); free(bkpth); free(nname); return (ABORT); } free(bkpth); if ((from = open(fn, O_RDONLY)) == -1) { free(nname); free(tname); return (FALSE); } to = mkstemp(tname); if (to == -1) { serrno = errno; close(from); free(nname); free(tname); errno = serrno; return (FALSE); } while ((nread = read(from, buf, sizeof(buf))) > 0) { if (write(to, buf, (size_t)nread) != nread) { nread = -1; break; } } serrno = errno; (void) fchmod(to, (sb.st_mode & 0777)); /* copy the mtime to the backupfile */ struct timespec new_times[2]; new_times[0] = sb.st_atim; new_times[1] = sb.st_mtim; futimens(to, new_times); close(from); close(to); if (nread == -1) { if (unlink(tname) == -1) ewprintf("Can't unlink temp : %s", strerror(errno)); } else { if (rename(tname, nname) == -1) { ewprintf("Can't rename temp : %s", strerror(errno)); (void) unlink(tname); nread = -1; } } free(nname); free(tname); errno = serrno; return (nread == -1 ? FALSE : TRUE); } /* * Convert "fn" to a canonicalized absolute filename, replacing * a leading ~/ with the user's home dir, following symlinks, and * remove all occurrences of /./ and /../ */ char * adjustname(const char *fn, int slashslash) { static char fnb[PATH_MAX]; const char *cp, *ep = NULL; char *path; if (slashslash == TRUE) { cp = fn + strlen(fn) - 1; for (; cp >= fn; cp--) { if (ep && (*cp == '/')) { fn = ep; break; } if (*cp == '/' || *cp == '~') ep = cp; else ep = NULL; } } if ((path = expandtilde(fn)) == NULL) return (NULL); if (realpath(path, fnb) == NULL) (void)strlcpy(fnb, path, sizeof(fnb)); free(path); return (fnb); } /* * Find a startup file for the user and return its name. As a service * to other pieces of code that may want to find a startup file (like * the terminal driver in particular), accepts a suffix to be appended * to the startup file name. */ char * startupfile(char *suffix) { static char file[NFILEN]; char *home; int ret; if ((home = getenv("HOME")) == NULL || *home == '\0') goto nohome; if (suffix == NULL) { ret = snprintf(file, sizeof(file), _PATH_MG_STARTUP, home); if (ret < 0 || ret >= sizeof(file)) return (NULL); } else { ret = snprintf(file, sizeof(file), _PATH_MG_TERM, home, suffix); if (ret < 0 || ret >= sizeof(file)) return (NULL); } if (access(file, R_OK) == 0) return (file); nohome: #ifdef STARTUPFILE if (suffix == NULL) { ret = snprintf(file, sizeof(file), "%s", STARTUPFILE); if (ret < 0 || ret >= sizeof(file)) return (NULL); } else { ret = snprintf(file, sizeof(file), "%s%s", STARTUPFILE, suffix); if (ret < 0 || ret >= sizeof(file)) return (NULL); } if (access(file, R_OK) == 0) return (file); #endif /* STARTUPFILE */ return (NULL); } int copy(char *frname, char *toname) { int ifd, ofd; char buf[BUFSIZ]; mode_t fmode = DEFFILEMODE; /* XXX?? */ struct stat orig; ssize_t sr; if ((ifd = open(frname, O_RDONLY)) == -1) return (FALSE); if (fstat(ifd, &orig) == -1) { dobeep(); ewprintf("fstat: %s", strerror(errno)); close(ifd); return (FALSE); } if ((ofd = open(toname, O_WRONLY|O_CREAT|O_TRUNC, fmode)) == -1) { close(ifd); return (FALSE); } while ((sr = read(ifd, buf, sizeof(buf))) > 0) { if (write(ofd, buf, (size_t)sr) != sr) { ewprintf("write error : %s", strerror(errno)); break; } } if (fchmod(ofd, orig.st_mode) == -1) ewprintf("Cannot set original mode : %s", strerror(errno)); if (sr == -1) { ewprintf("Read error : %s", strerror(errno)); close(ifd); close(ofd); return (FALSE); } /* * It is "normal" for this to fail since we can't guarantee that * we will be running as root. */ if (fchown(ofd, orig.st_uid, orig.st_gid) && errno != EPERM) ewprintf("Cannot set owner : %s", strerror(errno)); (void) close(ifd); (void) close(ofd); return (TRUE); } /* * return list of file names that match the name in buf. */ struct list * make_file_list(char *buf) { char *dir, *file, *cp; size_t len, preflen; int ret; DIR *dirp; struct dirent *dent; struct list *last, *current; char fl_name[NFILEN + 2]; char prefixx[NFILEN + 1]; /* * We need three different strings: * dir - the name of the directory containing what the user typed. * Must be a real unix file name, e.g. no ~user, etc.. * Must not end in /. * prefix - the portion of what the user typed that is before the * names we are going to find in the directory. Must have a * trailing / if the user typed it. * names from the directory - We open dir, and return prefix * concatenated with names. */ /* first we get a directory name we can look up */ /* * Names ending in . are potentially odd, because adjustname will * treat foo/bar/.. as a foo/, whereas we are * interested in names starting with .. */ len = strlen(buf); if (len && buf[len - 1] == '.') { buf[len - 1] = 'x'; dir = adjustname(buf, TRUE); buf[len - 1] = '.'; } else dir = adjustname(buf, TRUE); if (dir == NULL) return (NULL); /* * If the user typed a trailing / or the empty string * he wants us to use his file spec as a directory name. */ if (len && buf[len - 1] != '/') { file = strrchr(dir, '/'); if (file) { *file = '\0'; if (*dir == '\0') dir = "/"; } else return (NULL); } /* Now we get the prefix of the name the user typed. */ if (strlcpy(prefixx, buf, sizeof(prefixx)) >= sizeof(prefixx)) return (NULL); cp = strrchr(prefixx, '/'); if (cp == NULL) prefixx[0] = '\0'; else cp[1] = '\0'; preflen = strlen(prefixx); /* cp is the tail of buf that really needs to be compared. */ cp = buf + preflen; len = strlen(cp); /* * Now make sure that file names will fit in the buffers allocated. * SV files are fairly short. For BSD, something more general would * be required. */ if (preflen > NFILEN - MAXNAMLEN) return (NULL); /* loop over the specified directory, making up the list of files */ /* * Note that it is worth our time to filter out names that don't * match, even though our caller is going to do so again, and to * avoid doing the stat if completion is being done, because stat'ing * every file in the directory is relatively expensive. */ dirp = opendir(dir); if (dirp == NULL) return (NULL); last = NULL; while ((dent = readdir(dirp)) != NULL) { int isdir; if (strncmp(cp, dent->d_name, len) != 0) continue; isdir = 0; if (dent->d_type == DT_DIR) { isdir = 1; } else if (dent->d_type == DT_LNK || dent->d_type == DT_UNKNOWN) { struct stat statbuf; if (fstatat(dirfd(dirp), dent->d_name, &statbuf, 0) < 0) continue; if (S_ISDIR(statbuf.st_mode)) isdir = 1; } if ((current = malloc(sizeof(struct list))) == NULL) { free_file_list(last); closedir(dirp); return (NULL); } ret = snprintf(fl_name, sizeof(fl_name), "%s%s%s", prefixx, dent->d_name, isdir ? "/" : ""); if (ret < 0 || ret >= sizeof(fl_name)) { free(current); continue; } current->l_next = last; current->l_name = strdup(fl_name); last = current; } closedir(dirp); return (last); } /* * Test if a supplied filename refers to a directory * Returns ABORT on error, TRUE if directory. FALSE otherwise */ int fisdir(const char *fname) { struct stat statbuf; if (stat(fname, &statbuf) != 0) return (ABORT); if (S_ISDIR(statbuf.st_mode)) return (TRUE); return (FALSE); } /* * Check the mtime of the supplied filename. * Return TRUE if last mtime matches, FALSE if not, * If the stat fails, return TRUE and try the save anyway */ int fchecktime(struct buffer *bp) { struct stat sb; if (stat(bp->b_fname, &sb) == -1) return (TRUE); /* if (bp->b_fi.fi_mtime.tv_sec != sb.st_mtimespec.tv_sec || bp->b_fi.fi_mtime.tv_nsec != sb.st_mtimespec.tv_nsec) */ if (bp->b_fi.fi_mtime.tv_sec != sb.st_mtime) return (FALSE); return (TRUE); } /* * Location of backup file. This function creates the correct path. */ static char * bkuplocation(const char *fn) { struct stat sb; char *ret; if (bkupdir != NULL && (stat(bkupdir, &sb) == 0) && S_ISDIR(sb.st_mode) && !bkupleavetmp(fn)) { char fname[NFILEN]; const char *c; int i = 0, len; c = fn; len = strlen(bkupdir); while (*c != '\0') { /* Make sure we don't go over combined: * strlen(bkupdir + '/' + fname + '\0') */ if (i >= NFILEN - len - 1) return (NULL); if (*c == '/') { fname[i] = '!'; } else if (*c == '!') { if (i >= NFILEN - len - 2) return (NULL); fname[i++] = '!'; fname[i] = '!'; } else fname[i] = *c; i++; c++; } fname[i] = '\0'; if (asprintf(&ret, "%s/%s", bkupdir, fname) == -1) return (NULL); } else if ((ret = strndup(fn, NFILEN)) == NULL) return (NULL); return (ret); } int backuptohomedir(int f, int n) { const char *c = _PATH_MG_DIR; char *p; if (bkupdir == NULL) { p = adjustname(c, TRUE); bkupdir = strndup(p, NFILEN); if (bkupdir == NULL) return(FALSE); if (mkdir(bkupdir, 0700) == -1 && errno != EEXIST) { free(bkupdir); bkupdir = NULL; } } else { free(bkupdir); bkupdir = NULL; } return (TRUE); } /* * For applications that use mg as the editor and have a desire to keep * '~' files in /tmp, toggle the location: /tmp | ~/.mg.d */ int toggleleavetmp(int f, int n) { leavetmp = !leavetmp; return (TRUE); } /* * Returns TRUE if fn is located in the temp directory and we want to save * those backups there. */ int bkupleavetmp(const char *fn) { if (!leavetmp) return(FALSE); if (strncmp(fn, "/tmp", 4) == 0) return (TRUE); return (FALSE); } /* * Expand file names beginning with '~' if appropriate: * 1, if ./~fn exists, continue without expanding tilde. * 2, else, if username 'fn' exists, expand tilde with home directory path. * 3, otherwise, continue and create new buffer called ~fn. */ char * expandtilde(const char *fn) { struct passwd *pw; struct stat statbuf; const char *cp; char user[LOGIN_NAME_MAX], path[NFILEN]; char *un, *ret; size_t ulen, plen; path[0] = '\0'; if (fn[0] != '~' || stat(fn, &statbuf) == 0) { if ((ret = strndup(fn, NFILEN)) == NULL) return (NULL); return(ret); } cp = strchr(fn, '/'); if (cp == NULL) cp = fn + strlen(fn); /* point to the NUL byte */ ulen = cp - &fn[1]; if (ulen >= sizeof(user)) { if ((ret = strndup(fn, NFILEN)) == NULL) return (NULL); return(ret); } if (ulen == 0) { /* ~/ or ~ */ if ((un = getlogin()) != NULL) (void)strlcpy(user, un, sizeof(user)); else user[0] = '\0'; } else { /* ~user/ or ~user */ memcpy(user, &fn[1], ulen); user[ulen] = '\0'; } pw = getpwnam(user); if (pw != NULL) { plen = strlcpy(path, pw->pw_dir, sizeof(path)); if (plen == 0 || path[plen - 1] != '/') { if (strlcat(path, "/", sizeof(path)) >= sizeof(path)) { dobeep(); ewprintf("Path too long"); return (NULL); } } fn = cp; if (*fn == '/') fn++; } if (strlcat(path, fn, sizeof(path)) >= sizeof(path)) { dobeep(); ewprintf("Path too long"); return (NULL); } if ((ret = strndup(path, NFILEN)) == NULL) return (NULL); return (ret); } mg-20161005/funmap.c010064400017510001751000000200511276204466300126730ustar00hanboetes/* $OpenBSD: funmap.c,v 1.53 2016/04/14 17:05:32 lum Exp $ */ /* This file is in the public domain */ #include #include #include #include #include #include "def.h" #include "funmap.h" #include "kbd.h" /* * If the function is NULL, it must be listed with the * same name in the map_table. */ struct funmap { PF fn_funct; const char *fn_name; struct funmap *fn_next; }; static struct funmap *funs; static struct funmap functnames[] = { {apropos_command, "apropos",}, {toggleaudiblebell, "audible-bell",}, {auto_execute, "auto-execute",}, {fillmode, "auto-fill-mode",}, {indentmode, "auto-indent-mode",}, {backtoindent, "back-to-indentation",}, {backuptohomedir, "backup-to-home-directory",}, {backchar, "backward-char",}, {delbword, "backward-kill-word",}, {gotobop, "backward-paragraph",}, {backword, "backward-word",}, {gotobob, "beginning-of-buffer",}, {gotobol, "beginning-of-line",}, {showmatch, "blink-and-insert",}, {bsmap, "bsmap-mode",}, {NULL, "c-x 4 prefix",}, {NULL, "c-x prefix",}, {executemacro, "call-last-kbd-macro",}, {capword, "capitalize-word",}, {changedir, "cd",}, {clearmark, "clear-mark",}, {colnotoggle, "column-number-mode",}, {copyregion, "copy-region-as-kill",}, #ifdef REGEX {cntmatchlines, "count-matches",}, {cntnonmatchlines, "count-non-matches",}, #endif /* REGEX */ {cscreatelist, "cscope-create-list-of-files-to-index",}, {csfuncalled, "cscope-find-called-functions",}, {csegrep, "cscope-find-egrep-pattern",}, {csfindinc, "cscope-find-files-including-file",}, {cscallerfuncs, "cscope-find-functions-calling-this-function",}, {csdefinition, "cscope-find-global-definition",}, {csfindfile, "cscope-find-this-file",}, {cssymbol, "cscope-find-this-symbol",}, {csfindtext, "cscope-find-this-text-string",}, {csnextfile, "cscope-next-file",}, {csnextmatch, "cscope-next-symbol",}, {csprevfile, "cscope-prev-file",}, {csprevmatch, "cscope-prev-symbol",}, {redefine_key, "define-key",}, {backdel, "delete-backward-char",}, {deblank, "delete-blank-lines",}, {forwdel, "delete-char",}, {delwhite, "delete-horizontal-space",}, {delleadwhite, "delete-leading-space",}, #ifdef REGEX {delmatchlines, "delete-matching-lines",}, {delnonmatchlines, "delete-non-matching-lines",}, #endif /* REGEX */ {onlywind, "delete-other-windows",}, {deltrailwhite, "delete-trailing-space",}, {delwind, "delete-window",}, {wallchart, "describe-bindings",}, {desckey, "describe-key-briefly",}, {diffbuffer, "diff-buffer-with-file",}, {digit_argument, "digit-argument",}, {lowerregion, "downcase-region",}, {lowerword, "downcase-word",}, {showversion, "emacs-version",}, {finishmacro, "end-kbd-macro",}, {gotoeob, "end-of-buffer",}, {gotoeol, "end-of-line",}, {enlargewind, "enlarge-window",}, {NULL, "esc prefix",}, {evalbuffer, "eval-current-buffer",}, {evalexpr, "eval-expression",}, {swapmark, "exchange-point-and-mark",}, {extend, "execute-extended-command",}, {fillpara, "fill-paragraph",}, {filevisitalt, "find-alternate-file",}, {filevisit, "find-file",}, {poptofile, "find-file-other-window",}, {filevisitro, "find-file-read-only",}, {findtag, "find-tag",}, {forwchar, "forward-char",}, {gotoeop, "forward-paragraph",}, {forwword, "forward-word",}, {bindtokey, "global-set-key",}, {unbindtokey, "global-unset-key",}, {globalwdtoggle, "global-wd-mode",}, {gotoline, "goto-line",}, {help_help, "help-help",}, {indent, "indent-current-line",}, {insert, "insert",}, {bufferinsert, "insert-buffer",}, {fileinsert, "insert-file",}, {fillword, "insert-with-wrap",}, {backisearch, "isearch-backward",}, {forwisearch, "isearch-forward",}, {joinline, "join-line",}, {justone, "just-one-space",}, {ctrlg, "keyboard-quit",}, {killbuffer_cmd, "kill-buffer",}, {killline, "kill-line",}, {killpara, "kill-paragraph",}, {killregion, "kill-region",}, {delfword, "kill-word",}, {toggleleavetmp, "leave-tmpdir-backups",}, {linenotoggle, "line-number-mode",}, {listbuffers, "list-buffers",}, {evalfile, "load",}, {localbind, "local-set-key",}, {localunbind, "local-unset-key",}, {makebkfile, "make-backup-files",}, {makedir, "make-directory",}, {markpara, "mark-paragraph",}, {markbuffer, "mark-whole-buffer",}, {do_meta, "meta-key-mode",}, /* better name, anyone? */ {negative_argument, "negative-argument",}, {enewline, "newline",}, {lfindent, "newline-and-indent",}, {forwline, "next-line",}, #ifdef NOTAB {notabmode, "no-tab-mode",}, #endif /* NOTAB */ {notmodified, "not-modified",}, {openline, "open-line",}, {nextwind, "other-window",}, {overwrite_mode, "overwrite-mode",}, {poptag, "pop-tag-mark",}, {prefixregion, "prefix-region",}, {backline, "previous-line",}, {prevwind, "previous-window",}, {spawncli, "push-shell",}, {showcwdir, "pwd",}, {queryrepl, "query-replace",}, #ifdef REGEX {re_queryrepl, "query-replace-regexp",}, #endif /* REGEX */ {quote, "quoted-insert",}, #ifdef REGEX {re_searchagain, "re-search-again",}, {re_backsearch, "re-search-backward",}, {re_forwsearch, "re-search-forward",}, #endif /* REGEX */ {reposition, "recenter",}, {redraw, "redraw-display",}, #ifdef REGEX {replstr, "replace-string",}, #endif /* REGEX */ {revertbuffer, "revert-buffer",}, {filesave, "save-buffer",}, {quit, "save-buffers-kill-emacs",}, {savebuffers, "save-some-buffers",}, {backpage, "scroll-down",}, {back1page, "scroll-one-line-down",}, {forw1page, "scroll-one-line-up",}, {pagenext, "scroll-other-window",}, {forwpage, "scroll-up",}, {searchagain, "search-again",}, {backsearch, "search-backward",}, {forwsearch, "search-forward",}, {selfinsert, "self-insert-command",}, {sentencespace, "sentence-end-double-space",}, #ifdef REGEX {setcasefold, "set-case-fold-search",}, #endif /* REGEX */ {set_default_mode, "set-default-mode",}, {setfillcol, "set-fill-column",}, {setmark, "set-mark-command",}, {setprefix, "set-prefix-string",}, {shellcommand, "shell-command",}, {piperegion, "shell-command-on-region",}, {shrinkwind, "shrink-window",}, #ifdef NOTAB {space_to_tabstop, "space-to-tabstop",}, #endif /* NOTAB */ {splitwind, "split-window-vertically",}, {definemacro, "start-kbd-macro",}, {spawncli, "suspend-emacs",}, {usebuffer, "switch-to-buffer",}, {poptobuffer, "switch-to-buffer-other-window",}, {togglereadonly, "toggle-read-only" }, {twiddle, "transpose-chars",}, {transposepara, "transpose-paragraphs",}, {transposeword, "transpose-words",}, {undo, "undo",}, {undo_add_boundary, "undo-boundary",}, {undo_boundary_enable, "undo-boundary-toggle",}, {undo_enable, "undo-enable",}, {undo_dump, "undo-list",}, {universal_argument, "universal-argument",}, {upperregion, "upcase-region",}, {upperword, "upcase-word",}, {togglevisiblebell, "visible-bell",}, {tagsvisit, "visit-tags-table",}, {showcpos, "what-cursor-position",}, {filewrite, "write-file",}, {yank, "yank",}, {NULL, NULL,} }; void funmap_init(void) { struct funmap *fn; for (fn = functnames; fn->fn_name != NULL; fn++) { fn->fn_next = funs; funs = fn; } } int funmap_add(PF fun, const char *fname) { struct funmap *fn; if ((fn = malloc(sizeof(*fn))) == NULL) return (FALSE); fn->fn_funct = fun; fn->fn_name = fname; fn->fn_next = funs; funs = fn; return (TRUE); } /* * Translate from function name to function pointer. */ PF name_function(const char *fname) { struct funmap *fn; for (fn = funs; fn != NULL; fn = fn->fn_next) { if (strcmp(fn->fn_name, fname) == 0) return (fn->fn_funct); } return (NULL); } const char * function_name(PF fun) { struct funmap *fn; for (fn = funs; fn != NULL; fn = fn->fn_next) { if (fn->fn_funct == fun) return (fn->fn_name); } return (NULL); } /* * List possible function name completions. */ struct list * complete_function_list(const char *fname) { struct funmap *fn; struct list *head, *el; int len; len = strlen(fname); head = NULL; for (fn = funs; fn != NULL; fn = fn->fn_next) { if (memcmp(fname, fn->fn_name, len) == 0) { if ((el = malloc(sizeof(*el))) == NULL) { free_file_list(head); return (NULL); } el->l_name = strdup(fn->fn_name); el->l_next = head; head = el; } } return (head); } mg-20161005/grep.c010064400017510001751000000165471276204442100123510ustar00hanboetes/* $OpenBSD: grep.c,v 1.44 2015/03/19 21:48:05 bcallah Exp $ */ /* This file is in the public domain */ #include #include #include #include #include #include #include #include #include #include #include #include "def.h" #include "kbd.h" #include "funmap.h" int globalwd = FALSE; static int compile_goto_error(int, int); int next_error(int, int); static int grep(int, int); static int gid(int, int); static struct buffer *compile_mode(const char *, const char *); void grep_init(void); static char compile_last_command[NFILEN] = "make "; /* * Hints for next-error * * XXX - need some kind of callback to find out when those get killed. */ struct mgwin *compile_win; struct buffer *compile_buffer; static PF compile_pf[] = { compile_goto_error }; static struct KEYMAPE (1) compilemap = { 1, 1, rescan, { { CCHR('M'), CCHR('M'), compile_pf, NULL } } }; void grep_init(void) { funmap_add(compile_goto_error, "compile-goto-error"); funmap_add(next_error, "next-error"); funmap_add(grep, "grep"); funmap_add(compile, "compile"); funmap_add(gid, "gid"); maps_add((KEYMAP *)&compilemap, "compile"); } /* ARGSUSED */ static int grep(int f, int n) { char cprompt[NFILEN], *bufp; struct buffer *bp; struct mgwin *wp; (void)strlcpy(cprompt, "grep -n ", sizeof(cprompt)); if ((bufp = eread("Run grep: ", cprompt, NFILEN, EFDEF | EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if (strlcat(cprompt, " /dev/null", sizeof(cprompt)) >= sizeof(cprompt)) return (FALSE); if ((bp = compile_mode("*grep*", cprompt)) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; compile_win = curwp = wp; return (TRUE); } /* ARGSUSED */ int compile(int f, int n) { char cprompt[NFILEN], *bufp; struct buffer *bp; struct mgwin *wp; (void)strlcpy(cprompt, compile_last_command, sizeof(cprompt)); if ((bufp = eread("Compile command: ", cprompt, NFILEN, EFDEF | EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if (savebuffers(f, n) == ABORT) return (ABORT); (void)strlcpy(compile_last_command, bufp, sizeof(compile_last_command)); if ((bp = compile_mode("*compile*", cprompt)) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; compile_win = curwp = wp; gotoline(FFARG, 0); return (TRUE); } /* id-utils foo. */ /* ARGSUSED */ static int gid(int f, int n) { char command[NFILEN]; char cprompt[NFILEN], *bufp; int c; struct buffer *bp; struct mgwin *wp; int i, j, len; /* catch ([^\s(){}]+)[\s(){}]* */ i = curwp->w_doto; /* Skip backwards over delimiters we are currently on */ while (i > 0) { c = lgetc(curwp->w_dotp, i); if (isalnum(c) || c == '_') break; i--; } /* Skip the symbol itself */ for (; i > 0; i--) { c = lgetc(curwp->w_dotp, i - 1); if (!isalnum(c) && c != '_') break; } /* Fill the symbol in cprompt[] */ for (j = 0; j < sizeof(cprompt) - 1 && i < llength(curwp->w_dotp); j++, i++) { c = lgetc(curwp->w_dotp, i); if (!isalnum(c) && c != '_') break; cprompt[j] = c; } cprompt[j] = '\0'; if ((bufp = eread("Run gid (with args): ", cprompt, NFILEN, (j ? EFDEF : 0) | EFNEW | EFCR)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); len = snprintf(command, sizeof(command), "gid %s", cprompt); if (len < 0 || len >= sizeof(command)) return (FALSE); if ((bp = compile_mode("*gid*", command)) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; compile_win = curwp = wp; return (TRUE); } struct buffer * compile_mode(const char *name, const char *command) { struct buffer *bp; FILE *fpipe; char *buf; size_t len; int ret, n; char cwd[NFILEN], qcmd[NFILEN]; char timestr[NTIME]; time_t t; n = snprintf(qcmd, sizeof(qcmd), "%s 2>&1", command); if (n < 0 || n >= sizeof(qcmd)) return (NULL); bp = bfind(name, TRUE); if (bclear(bp) != TRUE) return (NULL); if (getbufcwd(bp->b_cwd, sizeof(bp->b_cwd)) != TRUE) return (NULL); addlinef(bp, "cd %s", bp->b_cwd); addline(bp, qcmd); addline(bp, ""); if (getcwd(cwd, sizeof(cwd)) == NULL) panic("Can't get current directory!"); if (chdir(bp->b_cwd) == -1) { dobeep(); ewprintf("Can't change dir to %s", bp->b_cwd); return (NULL); } if ((fpipe = popen(qcmd, "r")) == NULL) { dobeep(); ewprintf("Problem opening pipe"); return (NULL); } /* * We know that our commands are nice and the last line will end with * a \n, so we don't need to try to deal with the last line problem * in fgetln. */ while ((buf = fgetln(fpipe, &len)) != NULL) { buf[len - 1] = '\0'; addline(bp, buf); } ret = pclose(fpipe); t = time(NULL); strftime(timestr, sizeof(timestr), "%a %b %e %T %Y", localtime(&t)); addline(bp, ""); if (ret != 0) addlinef(bp, "Command exited abnormally with code %d" " at %s", ret, timestr); else addlinef(bp, "Command finished at %s", timestr); bp->b_dotp = bfirstlp(bp); bp->b_modes[0] = name_mode("fundamental"); bp->b_modes[1] = name_mode("compile"); bp->b_nmodes = 1; compile_buffer = bp; if (chdir(cwd) == -1) { dobeep(); ewprintf("Can't change dir back to %s", cwd); return (NULL); } return (bp); } /* ARGSUSED */ static int compile_goto_error(int f, int n) { struct buffer *bp; struct mgwin *wp; char *fname, *line, *lp, *ln; int lineno; char *adjf, path[NFILEN]; const char *errstr; struct line *last; compile_win = curwp; compile_buffer = curbp; last = blastlp(compile_buffer); retry: /* last line is compilation result */ if (curwp->w_dotp == last) return (FALSE); if ((line = linetostr(curwp->w_dotp)) == NULL) return (FALSE); lp = line; if ((fname = strsep(&lp, ":")) == NULL || *fname == '\0') goto fail; if ((ln = strsep(&lp, ":")) == NULL || *ln == '\0') goto fail; lineno = (int)strtonum(ln, INT_MIN, INT_MAX, &errstr); if (errstr) goto fail; if (fname && fname[0] != '/') { if (getbufcwd(path, sizeof(path)) == FALSE) goto fail; if (strlcat(path, fname, sizeof(path)) >= sizeof(path)) goto fail; adjf = path; } else { adjf = adjustname(fname, TRUE); } free(line); if (adjf == NULL) return (FALSE); if ((bp = findbuffer(adjf)) == NULL) return (FALSE); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); curbp = bp; curwp = wp; if (bp->b_fname[0] == '\0') readin(adjf); gotoline(FFARG, lineno); return (TRUE); fail: free(line); if (curwp->w_dotp != blastlp(curbp)) { curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_rflag |= WFMOVE; goto retry; } dobeep(); ewprintf("No more hits"); return (FALSE); } /* ARGSUSED */ int next_error(int f, int n) { if (compile_win == NULL || compile_buffer == NULL) { dobeep(); ewprintf("No compilation active"); return (FALSE); } curwp = compile_win; curbp = compile_buffer; if (curwp->w_dotp == blastlp(curbp)) { dobeep(); ewprintf("No more hits"); return (FALSE); } curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_rflag |= WFMOVE; return (compile_goto_error(f, n)); } /* * Since we don't have variables (we probably should) these are command * processors for changing the values of mode flags. */ /* ARGSUSED */ int globalwdtoggle(int f, int n) { if (f & FFARG) globalwd = n > 0; else globalwd = !globalwd; sgarbf = TRUE; return (TRUE); } mg-20161005/help.c010064400017510001751000000121541276204442100123320ustar00hanboetes/* $OpenBSD: help.c,v 1.35 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Help functions for Mg 2 */ #include #include #include #include #include "def.h" #include "funmap.h" #include "kbd.h" #include "key.h" #include "macro.h" static int showall(struct buffer *, KEYMAP *, char *); static int findbind(KEYMAP *, PF, char *, size_t); /* * Read a key from the keyboard, and look it up in the keymap. * Display the name of the function currently bound to the key. */ /* ARGSUSED */ int desckey(int f, int n) { KEYMAP *curmap; PF funct; int c, m, i, num; char *pep; char dprompt[80]; if (inmacro) return (TRUE); /* ignore inside keyboard macro */ num = strlcpy(dprompt, "Describe key briefly: ", sizeof(dprompt)); if (num >= sizeof(dprompt)) num = sizeof(dprompt) - 1; pep = dprompt + num; key.k_count = 0; m = curbp->b_nmodes; curmap = curbp->b_modes[m]->p_map; for (;;) { for (;;) { ewprintf("%s", dprompt); pep[-1] = ' '; pep = getkeyname(pep, sizeof(dprompt) - (pep - dprompt), key.k_chars[key.k_count++] = c = getkey(FALSE)); if ((funct = doscan(curmap, c, &curmap)) != NULL) break; *pep++ = '-'; *pep = '\0'; } if (funct != rescan) break; if (ISUPPER(key.k_chars[key.k_count - 1])) { funct = doscan(curmap, TOLOWER(key.k_chars[key.k_count - 1]), &curmap); if (funct == NULL) { *pep++ = '-'; *pep = '\0'; continue; } if (funct != rescan) break; } nextmode: if (--m < 0) break; curmap = curbp->b_modes[m]->p_map; for (i = 0; i < key.k_count; i++) { funct = doscan(curmap, key.k_chars[i], &curmap); if (funct != NULL) { if (i == key.k_count - 1 && funct != rescan) goto found; funct = rescan; goto nextmode; } } *pep++ = '-'; *pep = '\0'; } found: if (funct == rescan || funct == selfinsert) ewprintf("%k is not bound to any function"); else if ((pep = (char *)function_name(funct)) != NULL) ewprintf("%k runs the command %s", pep); else ewprintf("%k is bound to an unnamed function"); return (TRUE); } /* * This function creates a table, listing all of the command * keys and their current bindings, and stores the table in the * *help* pop-up buffer. This lets Mg produce it's own wall chart. */ /* ARGSUSED */ int wallchart(int f, int n) { int m; struct buffer *bp; bp = bfind("*help*", TRUE); if (bclear(bp) != TRUE) /* clear it out */ return (FALSE); bp->b_flag |= BFREADONLY; for (m = curbp->b_nmodes; m > 0; m--) { if ((addlinef(bp, "Local keybindings for mode %s:", curbp->b_modes[m]->p_name) == FALSE) || (showall(bp, curbp->b_modes[m]->p_map, "") == FALSE) || (addline(bp, "") == FALSE)) return (FALSE); } if ((addline(bp, "Global bindings:") == FALSE) || (showall(bp, fundamental_map, "") == FALSE)) return (FALSE); return (popbuftop(bp, WNONE)); } static int showall(struct buffer *bp, KEYMAP *map, char *prefix) { KEYMAP *newmap; char buf[80], keybuf[16]; PF fun; int c; if (addline(bp, "") == FALSE) return (FALSE); /* XXX - 256 ? */ for (c = 0; c < 256; c++) { fun = doscan(map, c, &newmap); if (fun == rescan || fun == selfinsert) continue; getkeyname(buf, sizeof(buf), c); (void)snprintf(keybuf, sizeof(keybuf), "%s%s ", prefix, buf); if (fun == NULL) { if (showall(bp, newmap, keybuf) == FALSE) return (FALSE); } else { if (addlinef(bp, "%-16s%s", keybuf, function_name(fun)) == FALSE) return (FALSE); } } return (TRUE); } int help_help(int f, int n) { KEYMAP *kp; PF funct; if ((kp = name_map("help")) == NULL) return (FALSE); ewprintf("a b c: "); do { funct = doscan(kp, getkey(FALSE), NULL); } while (funct == NULL || funct == help_help); if (macrodef && macrocount < MAXMACRO) macro[macrocount - 1].m_funct = funct; return ((*funct)(f, n)); } /* ARGSUSED */ int apropos_command(int f, int n) { struct buffer *bp; struct list *fnames, *el; char string[32]; if (eread("apropos: ", string, sizeof(string), EFNUL | EFNEW) == NULL) return (ABORT); /* FALSE means we got a 0 character string, which is fine */ bp = bfind("*help*", TRUE); if (bclear(bp) == FALSE) return (FALSE); fnames = complete_function_list(""); for (el = fnames; el != NULL; el = el->l_next) { char buf[32]; if (strstr(el->l_name, string) == NULL) continue; buf[0] = '\0'; findbind(fundamental_map, name_function(el->l_name), buf, sizeof(buf)); if (addlinef(bp, "%-32s%s", el->l_name, buf) == FALSE) { free_file_list(fnames); return (FALSE); } } free_file_list(fnames); return (popbuftop(bp, WNONE)); } static int findbind(KEYMAP *map, PF fun, char *buf, size_t len) { KEYMAP *newmap; PF nfun; char buf2[16], keybuf[16]; int c; /* XXX - 256 ? */ for (c = 0; c < 256; c++) { nfun = doscan(map, c, &newmap); if (nfun == fun) { getkeyname(buf, len, c); return (TRUE); } if (nfun == NULL) { if (findbind(newmap, fun, buf2, sizeof(buf2)) == TRUE) { getkeyname(keybuf, sizeof(keybuf), c); (void)snprintf(buf, len, "%s %s", keybuf, buf2); return (TRUE); } } } return (FALSE); } mg-20161005/kbd.c010064400017510001751000000210521276204442100121370ustar00hanboetes/* $OpenBSD: kbd.c,v 1.30 2015/09/26 21:51:58 jasper Exp $ */ /* This file is in the public domain. */ /* * Terminal independent keyboard handling. */ #include #include #include #include "def.h" #include "kbd.h" #include "key.h" #include "macro.h" #define METABIT 0x80 #define PROMPTL 80 char prompt[PROMPTL] = "", *promptp = prompt; static int mgwrap(PF, int, int); static int use_metakey = TRUE; static int pushed = FALSE; static int pushedc; struct map_element *ele; struct key key; /* * Toggle the value of use_metakey */ int do_meta(int f, int n) { if (f & FFARG) use_metakey = n > 0; else use_metakey = !use_metakey; ewprintf("Meta keys %sabled", use_metakey ? "en" : "dis"); return (TRUE); } static int bs_map = 0; /* * Toggle backspace mapping */ int bsmap(int f, int n) { if (f & FFARG) bs_map = n > 0; else bs_map = !bs_map; ewprintf("Backspace mapping %sabled", bs_map ? "en" : "dis"); return (TRUE); } void ungetkey(int c) { if (use_metakey && pushed && c == CCHR('[')) pushedc |= METABIT; else pushedc = c; pushed = TRUE; } int getkey(int flag) { int c; if (flag && !pushed) { if (prompt[0] != '\0' && ttwait(2000)) { /* avoid problems with % */ ewprintf("%s", prompt); /* put the cursor back */ update(CMODE); epresf = KCLEAR; } if (promptp > prompt) *(promptp - 1) = ' '; } if (pushed) { c = pushedc; pushed = FALSE; } else c = ttgetc(); if (bs_map) { if (c == CCHR('H')) c = CCHR('?'); else if (c == CCHR('?')) c = CCHR('H'); } if (use_metakey && (c & METABIT)) { pushedc = c & ~METABIT; pushed = TRUE; c = CCHR('['); } if (flag && promptp < &prompt[PROMPTL - 5]) { promptp = getkeyname(promptp, sizeof(prompt) - (promptp - prompt) - 1, c); *promptp++ = '-'; *promptp = '\0'; } return (c); } /* * doscan scans a keymap for a keyboard character and returns a pointer * to the function associated with that character. Sets ele to the * keymap element the keyboard was found in as a side effect. */ PF doscan(KEYMAP *map, int c, KEYMAP **newmap) { struct map_element *elec = &map->map_element[0]; struct map_element *last = &map->map_element[map->map_num]; PF ret; while (elec < last && c > elec->k_num) elec++; /* used by prefix and binding code */ ele = elec; if (elec >= last || c < elec->k_base) ret = map->map_default; else ret = elec->k_funcp[c - elec->k_base]; if (ret == NULL && newmap != NULL) *newmap = elec->k_prefmap; return (ret); } int doin(void) { KEYMAP *curmap; PF funct; *(promptp = prompt) = '\0'; curmap = curbp->b_modes[curbp->b_nmodes]->p_map; key.k_count = 0; while ((funct = doscan(curmap, (key.k_chars[key.k_count++] = getkey(TRUE)), &curmap)) == NULL) /* nothing */; if (macrodef && macrocount < MAXMACRO) macro[macrocount++].m_funct = funct; return (mgwrap(funct, 0, 1)); } int rescan(int f, int n) { int c; KEYMAP *curmap; int i; PF fp = NULL; int md = curbp->b_nmodes; for (;;) { if (ISUPPER(key.k_chars[key.k_count - 1])) { c = TOLOWER(key.k_chars[key.k_count - 1]); curmap = curbp->b_modes[md]->p_map; for (i = 0; i < key.k_count - 1; i++) { if ((fp = doscan(curmap, (key.k_chars[i]), &curmap)) != NULL) break; } if (fp == NULL) { if ((fp = doscan(curmap, c, NULL)) == NULL) while ((fp = doscan(curmap, key.k_chars[key.k_count++] = getkey(TRUE), &curmap)) == NULL) /* nothing */; if (fp != rescan) { if (macrodef && macrocount <= MAXMACRO) macro[macrocount - 1].m_funct = fp; return (mgwrap(fp, f, n)); } } } /* try previous mode */ if (--md < 0) return (ABORT); curmap = curbp->b_modes[md]->p_map; for (i = 0; i < key.k_count; i++) { if ((fp = doscan(curmap, (key.k_chars[i]), &curmap)) != NULL) break; } if (fp == NULL) { while ((fp = doscan(curmap, key.k_chars[i++] = getkey(TRUE), &curmap)) == NULL) /* nothing */; key.k_count = i; } if (fp != rescan && i >= key.k_count - 1) { if (macrodef && macrocount <= MAXMACRO) macro[macrocount - 1].m_funct = fp; return (mgwrap(fp, f, n)); } } } int universal_argument(int f, int n) { KEYMAP *curmap; PF funct; int c, nn = 4; if (f & FFUNIV) nn *= n; for (;;) { key.k_chars[0] = c = getkey(TRUE); key.k_count = 1; if (c == '-') return (negative_argument(f, nn)); if (c >= '0' && c <= '9') return (digit_argument(f, nn)); curmap = curbp->b_modes[curbp->b_nmodes]->p_map; while ((funct = doscan(curmap, c, &curmap)) == NULL) { key.k_chars[key.k_count++] = c = getkey(TRUE); } if (funct != universal_argument) { if (macrodef && macrocount < MAXMACRO - 1) { if (f & FFARG) macrocount--; macro[macrocount++].m_count = nn; macro[macrocount++].m_funct = funct; } return (mgwrap(funct, FFUNIV, nn)); } nn <<= 2; } } /* ARGSUSED */ int digit_argument(int f, int n) { KEYMAP *curmap; PF funct; int nn, c; nn = key.k_chars[key.k_count - 1] - '0'; for (;;) { c = getkey(TRUE); if (c < '0' || c > '9') break; nn *= 10; nn += c - '0'; } key.k_chars[0] = c; key.k_count = 1; curmap = curbp->b_modes[curbp->b_nmodes]->p_map; while ((funct = doscan(curmap, c, &curmap)) == NULL) { key.k_chars[key.k_count++] = c = getkey(TRUE); } if (macrodef && macrocount < MAXMACRO - 1) { if (f & FFARG) macrocount--; else macro[macrocount - 1].m_funct = universal_argument; macro[macrocount++].m_count = nn; macro[macrocount++].m_funct = funct; } return (mgwrap(funct, FFOTHARG, nn)); } int negative_argument(int f, int n) { KEYMAP *curmap; PF funct; int c; int nn = 0; for (;;) { c = getkey(TRUE); if (c < '0' || c > '9') break; nn *= 10; nn += c - '0'; } if (nn) nn = -nn; else nn = -n; key.k_chars[0] = c; key.k_count = 1; curmap = curbp->b_modes[curbp->b_nmodes]->p_map; while ((funct = doscan(curmap, c, &curmap)) == NULL) { key.k_chars[key.k_count++] = c = getkey(TRUE); } if (macrodef && macrocount < MAXMACRO - 1) { if (f & FFARG) macrocount--; else macro[macrocount - 1].m_funct = universal_argument; macro[macrocount++].m_count = nn; macro[macrocount++].m_funct = funct; } return (mgwrap(funct, FFNEGARG, nn)); } /* * Insert a character. While defining a macro, create a "LINE" containing * all inserted characters. */ int selfinsert(int f, int n) { struct line *lp; int c; int count; if (n < 0) return (FALSE); if (n == 0) return (TRUE); c = key.k_chars[key.k_count - 1]; if (macrodef && macrocount < MAXMACRO) { if (f & FFARG) macrocount -= 2; /* last command was insert -- tack on the end */ if (lastflag & CFINS) { macrocount--; /* Ensure the line can handle the new characters */ if (maclcur->l_size < maclcur->l_used + n) { if (lrealloc(maclcur, maclcur->l_used + n) == FALSE) return (FALSE); } maclcur->l_used += n; /* Copy in the new data */ for (count = maclcur->l_used - n; count < maclcur->l_used; count++) maclcur->l_text[count] = c; } else { macro[macrocount - 1].m_funct = insert; if ((lp = lalloc(n)) == NULL) return (FALSE); lp->l_bp = maclcur; lp->l_fp = maclcur->l_fp; maclcur->l_fp = lp; maclcur = lp; for (count = 0; count < n; count++) lp->l_text[count] = c; } thisflag |= CFINS; } if (c == '\n') { do { count = lnewline(); } while (--n && count == TRUE); return (count); } /* overwrite mode */ if (curbp->b_flag & BFOVERWRITE) { lchange(WFEDIT); while (curwp->w_doto < llength(curwp->w_dotp) && n--) lputc(curwp->w_dotp, curwp->w_doto++, c); if (n <= 0) return (TRUE); } return (linsert(n, c)); } /* * This could be implemented as a keymap with everything defined as self-insert. */ int quote(int f, int n) { int c; key.k_count = 1; if ((key.k_chars[0] = getkey(TRUE)) >= '0' && key.k_chars[0] <= '7') { key.k_chars[0] -= '0'; if ((c = getkey(TRUE)) >= '0' && c <= '7') { key.k_chars[0] <<= 3; key.k_chars[0] += c - '0'; if ((c = getkey(TRUE)) >= '0' && c <= '7') { key.k_chars[0] <<= 3; key.k_chars[0] += c - '0'; } else ungetkey(c); } else ungetkey(c); } return (selfinsert(f, n)); } /* * Wraper function to count invocation repeats. * We ignore any function whose sole purpose is to get us * to the intended function. */ static int mgwrap(PF funct, int f, int n) { static PF ofp; if (funct != rescan && funct != negative_argument && funct != digit_argument && funct != universal_argument) { if (funct == ofp) rptcount++; else rptcount = 0; ofp = funct; } return ((*funct)(f, n)); } mg-20161005/keymap.c010064400017510001751000000217201276204442100126670ustar00hanboetes/* $OpenBSD: keymap.c,v 1.58 2015/12/29 19:44:32 lum Exp $ */ /* This file is in the public domain. */ /* * Keyboard maps. This is character set dependent. The terminal specific * parts of building the keymap has been moved to a better place. */ #include #include #include #include #include #include "def.h" #include "kbd.h" /* * initial keymap declarations, deepest first */ static PF cHcG[] = { ctrlg, /* ^G */ help_help /* ^H */ }; static PF cHa[] = { apropos_command, /* a */ wallchart, /* b */ desckey /* c */ }; struct KEYMAPE (2) helpmap = { 2, 2, rescan, { { CCHR('G'), CCHR('H'), cHcG, NULL }, { 'a', 'c', cHa, NULL } } }; static PF cCsc[] = { cscallerfuncs, /* c */ csdefinition, /* d */ csegrep, /* e */ csfindfile, /* f */ rescan, /* g */ rescan, /* h */ csfindinc, /* i */ rescan, /* j */ rescan, /* k */ rescan, /* l */ rescan, /* m */ csnextmatch, /* n */ rescan, /* o */ csprevmatch, /* p */ rescan, /* q */ rescan, /* r */ cssymbol, /* s */ csfindtext /* t */ }; static struct KEYMAPE (1) cCsmap = { 1, 1, rescan, { { 'c', 't', cCsc, NULL } } }; static PF cCs[] = { NULL /* s */ }; struct KEYMAPE (2) ccmap = { 2, 2, rescan, { { CCHR('@'), CCHR('@'), (PF[]){ rescan }, NULL }, { 's', 's', cCs, (KEYMAP *) & cCsmap } } }; static PF cX4cF[] = { poptofile, /* ^f */ ctrlg /* ^g */ }; static PF cX4b[] = { poptobuffer, /* b */ rescan, /* c */ rescan, /* d */ rescan, /* e */ poptofile /* f */ }; static struct KEYMAPE (2) cX4map = { 2, 2, rescan, { { CCHR('F'), CCHR('G'), cX4cF, NULL }, { 'b', 'f', cX4b, NULL } } }; static PF cXcB[] = { listbuffers, /* ^B */ quit, /* ^C */ rescan, /* ^D */ rescan, /* ^E */ filevisit, /* ^F */ ctrlg /* ^G */ }; static PF cXcL[] = { lowerregion, /* ^L */ rescan, /* ^M */ rescan, /* ^N */ deblank, /* ^O */ rescan, /* ^P */ togglereadonly, /* ^Q */ filevisitro, /* ^R */ filesave, /* ^S */ rescan, /* ^T */ upperregion, /* ^U */ filevisitalt, /* ^V */ filewrite, /* ^W */ swapmark /* ^X */ }; static PF cXlp[] = { definemacro, /* ( */ finishmacro /* ) */ }; static PF cX0[] = { delwind, /* 0 */ onlywind, /* 1 */ splitwind, /* 2 */ rescan, /* 3 */ NULL /* 4 */ }; static PF cXeq[] = { showcpos /* = */ }; static PF cXcar[] = { enlargewind, /* ^ */ rescan, /* _ */ next_error, /* ` */ rescan, /* a */ usebuffer, /* b */ rescan, /* c */ rescan, /* d */ executemacro, /* e */ setfillcol, /* f */ gotoline, /* g */ markbuffer, /* h */ fileinsert, /* i */ rescan, /* j */ killbuffer_cmd, /* k */ rescan, /* l */ rescan, /* m */ nextwind, /* n */ nextwind, /* o */ prevwind, /* p */ rescan, /* q */ rescan, /* r */ savebuffers, /* s */ rescan, /* t */ undo /* u */ }; struct KEYMAPE (6) cXmap = { 6, 6, rescan, { { CCHR('B'), CCHR('G'), cXcB, NULL }, { CCHR('L'), CCHR('X'), cXcL, NULL }, { '(', ')', cXlp, NULL }, { '0', '4', cX0, (KEYMAP *) & cX4map }, { '=', '=', cXeq, NULL }, { '^', 'u', cXcar, NULL } } }; static PF metacG[] = { ctrlg /* ^G */ }; static PF metacV[] = { pagenext /* ^V */ }; static PF metaspex[] = { justone, /* space */ shellcommand /* ! */ }; static PF metapct[] = { queryrepl /* % */ }; static PF metami[] = { poptag, /* * */ rescan, /* + */ rescan, /* , */ negative_argument, /* - */ findtag, /* . */ rescan, /* / */ digit_argument, /* 0 */ digit_argument, /* 1 */ digit_argument, /* 2 */ digit_argument, /* 3 */ digit_argument, /* 4 */ digit_argument, /* 5 */ digit_argument, /* 6 */ digit_argument, /* 7 */ digit_argument, /* 8 */ digit_argument, /* 9 */ rescan, /* : */ rescan, /* ; */ gotobob, /* < */ rescan, /* = */ gotoeob /* > */ }; static PF metasqf[] = { NULL, /* [ */ delwhite, /* \ */ rescan, /* ] */ joinline, /* ^ */ rescan, /* _ */ rescan, /* ` */ rescan, /* a */ backword, /* b */ capword, /* c */ delfword, /* d */ rescan, /* e */ forwword, /* f */ rescan, /* g */ markpara /* h */ }; static PF metal[] = { lowerword, /* l */ backtoindent, /* m */ rescan, /* n */ rescan, /* o */ rescan, /* p */ fillpara, /* q */ backsearch, /* r */ forwsearch, /* s */ transposeword, /* t */ upperword, /* u */ backpage, /* v */ copyregion, /* w */ extend, /* x */ rescan, /* y */ rescan, /* z */ gotobop, /* { */ piperegion, /* | */ gotoeop /* } */ }; static PF metasqlZ[] = { rescan /* Z */ }; static PF metatilde[] = { notmodified, /* ~ */ delbword /* DEL */ }; struct KEYMAPE (1) metasqlmap = { 1, 1, rescan, { { 'Z', 'Z', metasqlZ, NULL } } }; struct KEYMAPE (8) metamap = { 8, 8, rescan, { { CCHR('G'), CCHR('G'), metacG, NULL }, { CCHR('V'), CCHR('V'), metacV, NULL }, { ' ', '!', metaspex, NULL }, { '%', '%', metapct, NULL }, { '*', '>', metami, NULL }, { '[', 'h', metasqf, (KEYMAP *) &metasqlmap }, { 'l', '}', metal, NULL }, { '~', CCHR('?'), metatilde, NULL } } }; static PF fund_at[] = { setmark, /* ^@ */ gotobol, /* ^A */ backchar, /* ^B */ NULL, /* ^C */ forwdel, /* ^D */ gotoeol, /* ^E */ forwchar, /* ^F */ ctrlg, /* ^G */ }; static PF fund_h[] = { NULL, /* ^H */ }; /* ^I is selfinsert */ static PF fund_CJ[] = { lfindent, /* ^J */ killline, /* ^K */ reposition, /* ^L */ enewline, /* ^M */ forwline, /* ^N */ openline, /* ^O */ backline, /* ^P */ quote, /* ^Q */ backisearch, /* ^R */ forwisearch, /* ^S */ twiddle, /* ^T */ universal_argument, /* ^U */ forwpage, /* ^V */ killregion, /* ^W */ NULL, /* ^X */ yank, /* ^Y */ spawncli /* ^Z */ }; static PF fund_esc[] = { NULL, /* esc */ rescan, /* ^\ selfinsert is default on fundamental */ rescan, /* ^] */ rescan, /* ^^ */ undo /* ^_ */ }; static PF fund_del[] = { backdel /* DEL */ }; static PF fund_cb[] = { showmatch /* ) ] } */ }; static struct KEYMAPE (8) fundmap = { 8, 8, selfinsert, { { CCHR('@'), CCHR('G'), fund_at, (KEYMAP *) & ccmap }, { CCHR('H'), CCHR('H'), fund_h, (KEYMAP *) & helpmap }, { CCHR('J'), CCHR('Z'), fund_CJ, (KEYMAP *) & cXmap }, { CCHR('['), CCHR('_'), fund_esc, (KEYMAP *) & metamap }, { ')', ')', fund_cb, NULL }, { ']', ']', fund_cb, NULL }, { '}', '}', fund_cb, NULL }, { CCHR('?'), CCHR('?'), fund_del, NULL }, } }; static PF fill_sp[] = { fillword /* ' ' */ }; static struct KEYMAPE (1) fillmap = { 1, 1, rescan, { { ' ', ' ', fill_sp, NULL } } }; static PF indent_lf[] = { enewline, /* ^J */ rescan, /* ^K */ rescan, /* ^L */ lfindent /* ^M */ }; static struct KEYMAPE (1) indntmap = { 1, 1, rescan, { { CCHR('J'), CCHR('M'), indent_lf, NULL } } }; #ifdef NOTAB static PF notab_tab[] = { space_to_tabstop /* ^I */ }; static struct KEYMAPE (1) notabmap = { 1, 1, rescan, { { CCHR('I'), CCHR('I'), notab_tab, NULL } } }; #endif /* NOTAB */ static struct KEYMAPE (1) overwmap = { 0, 1, /* 1 to avoid 0 sized array */ rescan, { /* unused dummy entry for VMS C */ { (KCHAR)0, (KCHAR)0, NULL, NULL } } }; /* * The basic (root) keyboard map */ struct maps_s fundamental_mode = { (KEYMAP *)&fundmap, "fundamental" }; /* * give names to the maps, for use by help etc. If the map is to be bindable, * it must also be listed in the function name table below with the same * name. Maps created dynamically currently don't get added here, thus are * unnamed. Modes are just named keymaps with functions to add/subtract them * from a buffer's list of modes. If you change a mode name, change it in * modes.c also. */ static struct maps_s map_table[] = { {(KEYMAP *) &fillmap, "fill",}, {(KEYMAP *) &indntmap, "indent",}, #ifdef NOTAB {(KEYMAP *) ¬abmap, "notab",}, #endif /* NOTAB */ {(KEYMAP *) &overwmap, "overwrite",}, {(KEYMAP *) &metamap, "esc prefix",}, {(KEYMAP *) &cXmap, "c-x prefix",}, {(KEYMAP *) &cX4map, "c-x 4 prefix",}, {(KEYMAP *) &helpmap, "help",}, {NULL, NULL} }; struct maps_s *maps; void maps_init(void) { int i; struct maps_s *mp; maps = &fundamental_mode; for (i = 0; map_table[i].p_name != NULL; i++) { mp = &map_table[i]; mp->p_next = maps; maps = mp; } } /* * Insert a new (named) keymap at the head of the keymap list. */ int maps_add(KEYMAP *map, const char *name) { struct maps_s *mp; if ((mp = malloc(sizeof(*mp))) == NULL) return (FALSE); mp->p_name = name; mp->p_map = map; mp->p_next = maps; maps = mp; return (TRUE); } struct maps_s * name_mode(const char *name) { struct maps_s *mp; for (mp = maps; mp != NULL; mp = mp->p_next) if (strcmp(mp->p_name, name) == 0) return (mp); return (NULL); } KEYMAP * name_map(const char *name) { struct maps_s *mp; return ((mp = name_mode(name)) == NULL ? NULL : mp->p_map); } mg-20161005/line.c010064400017510001751000000315401276204442100123310ustar00hanboetes/* $OpenBSD: line.c,v 1.58 2015/12/11 20:21:23 mmcc Exp $ */ /* This file is in the public domain. */ /* * Text line handling. * * The functions in this file are a general set of line management * utilities. They are the only routines that touch the text. They * also touch the buffer and window structures to make sure that the * necessary updating gets done. * * Note that this code only updates the dot and mark values in the window * list. Since all the code acts on the current window, the buffer that * we are editing must be displayed, which means that "b_nwnd" is non-zero, * which means that the dot and mark values in the buffer headers are * nonsense. */ #include #include #include #include #include #include #include "def.h" /* * Allocate a new line of size `used'. lrealloc() can be called if the line * ever needs to grow beyond that. */ struct line * lalloc(int used) { struct line *lp; if ((lp = malloc(sizeof(*lp))) == NULL) return (NULL); lp->l_text = NULL; lp->l_size = 0; lp->l_used = used; /* XXX */ if (lrealloc(lp, used) == FALSE) { free(lp); return (NULL); } return (lp); } int lrealloc(struct line *lp, int newsize) { char *tmp; if (lp->l_size < newsize) { if ((tmp = realloc(lp->l_text, newsize)) == NULL) return (FALSE); lp->l_text = tmp; lp->l_size = newsize; } return (TRUE); } /* * Delete line "lp". Fix all of the links that might point to it (they are * moved to offset 0 of the next line. Unlink the line from whatever buffer * it might be in, and release the memory. The buffers are updated too; the * magic conditions described in the above comments don't hold here. */ void lfree(struct line *lp) { struct buffer *bp; struct mgwin *wp; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp) wp->w_linep = lp->l_fp; if (wp->w_dotp == lp) { wp->w_dotp = lp->l_fp; wp->w_doto = 0; } if (wp->w_markp == lp) { wp->w_markp = lp->l_fp; wp->w_marko = 0; } } for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (bp->b_nwnd == 0) { if (bp->b_dotp == lp) { bp->b_dotp = lp->l_fp; bp->b_doto = 0; } if (bp->b_markp == lp) { bp->b_markp = lp->l_fp; bp->b_marko = 0; } } } lp->l_bp->l_fp = lp->l_fp; lp->l_fp->l_bp = lp->l_bp; free(lp->l_text); free(lp); } /* * This routine is called when a character changes in place in the current * buffer. It updates all of the required flags in the buffer and window * system. The flag used is passed as an argument; if the buffer is being * displayed in more than 1 window we change EDIT to HARD. Set MODE if the * mode line needs to be updated (the "*" has to be set). */ void lchange(int flag) { struct mgwin *wp; /* update mode lines if this is the first change. */ if ((curbp->b_flag & BFCHG) == 0) { flag |= WFMODE; curbp->b_flag |= BFCHG; } for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { wp->w_rflag |= flag; if (wp != curwp) wp->w_rflag |= WFFULL; } } } /* * Insert "n" copies of the character "c" at the current location of dot. * In the easy case all that happens is the text is stored in the line. * In the hard case, the line has to be reallocated. When the window list * is updated, take special care; I screwed it up once. You always update * dot in the current window. You update mark and a dot in another window * if it is greater than the place where you did the insert. Return TRUE * if all is well, and FALSE on errors. */ int linsert(int n, int c) { struct line *lp1; struct mgwin *wp; RSIZE i; int doto; int s; if (!n) return (TRUE); if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read only"); return (FALSE); } lchange(WFEDIT); /* current line */ lp1 = curwp->w_dotp; /* special case for the end */ if (lp1 == curbp->b_headp) { struct line *lp2, *lp3; /* now should only happen in empty buffer */ if (curwp->w_doto != 0) { dobeep(); ewprintf("bug: linsert"); return (FALSE); } /* allocate a new line */ if ((lp2 = lalloc(n)) == NULL) return (FALSE); /* previous line */ lp3 = lp1->l_bp; /* link in */ lp3->l_fp = lp2; lp2->l_fp = lp1; lp1->l_bp = lp2; lp2->l_bp = lp3; for (i = 0; i < n; ++i) lp2->l_text[i] = c; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp1) wp->w_linep = lp2; if (wp->w_dotp == lp1) wp->w_dotp = lp2; if (wp->w_markp == lp1) wp->w_markp = lp2; } undo_add_insert(lp2, 0, n); curwp->w_doto = n; return (TRUE); } /* save for later */ doto = curwp->w_doto; if ((lp1->l_used + n) > lp1->l_size) { if (lrealloc(lp1, lp1->l_used + n) == FALSE) return (FALSE); } lp1->l_used += n; if (lp1->l_used != n) memmove(&lp1->l_text[doto + n], &lp1->l_text[doto], lp1->l_used - n - doto); /* Add the characters */ for (i = 0; i < n; ++i) lp1->l_text[doto + i] = c; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_dotp == lp1) { if (wp == curwp || wp->w_doto > doto) wp->w_doto += n; } if (wp->w_markp == lp1) { if (wp->w_marko > doto) wp->w_marko += n; } } undo_add_insert(curwp->w_dotp, doto, n); return (TRUE); } /* * Do the work of inserting a newline at the given line/offset. * If mark is on the current line, we may have to move the markline * to keep line numbers in sync. * lnewline_at assumes the current buffer is writable. Checking for * this fact should be done by the caller. */ int lnewline_at(struct line *lp1, int doto) { struct line *lp2; struct mgwin *wp; int nlen, tcurwpdotline; lchange(WFFULL); curwp->w_bufp->b_lines++; /* Check if mark is past dot (even on current line) */ if (curwp->w_markline > curwp->w_dotline || (curwp->w_dotline == curwp->w_markline && curwp->w_marko >= doto)) curwp->w_markline++; tcurwpdotline = curwp->w_dotline; /* If start of line, allocate a new line instead of copying */ if (doto == 0) { /* new first part */ if ((lp2 = lalloc(0)) == NULL) return (FALSE); lp2->l_bp = lp1->l_bp; lp1->l_bp->l_fp = lp2; lp2->l_fp = lp1; lp1->l_bp = lp2; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp1) wp->w_linep = lp2; if (wp->w_dotline >= tcurwpdotline) wp->w_dotline++; } undo_add_boundary(FFRAND, 1); undo_add_insert(lp2, 0, 1); undo_add_boundary(FFRAND, 1); return (TRUE); } /* length of new part */ nlen = llength(lp1) - doto; /* new second half line */ if ((lp2 = lalloc(nlen)) == NULL) return (FALSE); if (nlen != 0) bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen); lp1->l_used = doto; lp2->l_bp = lp1; lp2->l_fp = lp1->l_fp; lp1->l_fp = lp2; lp2->l_fp->l_bp = lp2; /* Windows */ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_dotp == lp1 && wp->w_doto >= doto) { wp->w_dotp = lp2; wp->w_doto -= doto; wp->w_dotline++; } else if (wp->w_dotline > tcurwpdotline) wp->w_dotline++; if (wp->w_markp == lp1 && wp->w_marko >= doto) { wp->w_markp = lp2; wp->w_marko -= doto; } } undo_add_boundary(FFRAND, 1); undo_add_insert(lp1, llength(lp1), 1); undo_add_boundary(FFRAND, 1); return (TRUE); } /* * Insert a newline into the buffer at the current location of dot in the * current window. */ int lnewline(void) { int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read only"); return (FALSE); } return (lnewline_at(curwp->w_dotp, curwp->w_doto)); } /* * This function deletes "n" bytes, starting at dot. (actually, n+1, as the * newline is included) It understands how to deal with end of lines, etc. * It returns TRUE if all of the characters were deleted, and FALSE if * they were not (because dot ran into the end of the buffer). * The "kflag" indicates either no insertion, or direction of insertion * into the kill buffer. */ int ldelete(RSIZE n, int kflag) { struct line *dotp; RSIZE chunk; struct mgwin *wp; int doto; char *cp1, *cp2; size_t len; char *sv = NULL; int end; int s; int rval = FALSE; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read only"); goto out; } len = n; if ((sv = calloc(1, len + 1)) == NULL) goto out; end = 0; undo_add_delete(curwp->w_dotp, curwp->w_doto, n, (kflag & KREG)); while (n != 0) { dotp = curwp->w_dotp; doto = curwp->w_doto; /* Hit the end of the buffer */ if (dotp == curbp->b_headp) goto out; /* Size of the chunk */ chunk = dotp->l_used - doto; if (chunk > n) chunk = n; /* End of line, merge */ if (chunk == 0) { if (dotp == blastlp(curbp)) goto out; lchange(WFFULL); if (ldelnewline() == FALSE) goto out; end = strlcat(sv, "\n", len + 1); --n; continue; } lchange(WFEDIT); /* Scrunch text */ cp1 = &dotp->l_text[doto]; memcpy(&sv[end], cp1, chunk); end += chunk; sv[end] = '\0'; for (cp2 = cp1 + chunk; cp2 < &dotp->l_text[dotp->l_used]; cp2++) *cp1++ = *cp2; dotp->l_used -= (int)chunk; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_dotp == dotp && wp->w_doto >= doto) { wp->w_doto -= chunk; if (wp->w_doto < doto) wp->w_doto = doto; } if (wp->w_markp == dotp && wp->w_marko >= doto) { wp->w_marko -= chunk; if (wp->w_marko < doto) wp->w_marko = doto; } } n -= chunk; } if (kchunk(sv, (RSIZE)len, kflag) != TRUE) goto out; rval = TRUE; out: free(sv); return (rval); } /* * Delete a newline and join the current line with the next line. If the next * line is the magic header line always return TRUE; merging the last line * with the header line can be thought of as always being a successful * operation. Even if nothing is done, this makes the kill buffer work * "right". If the mark is past the dot (actually, markline > dotline), * decrease the markline accordingly to keep line numbers in sync. * Easy cases can be done by shuffling data around. Hard cases * require that lines be moved about in memory. Return FALSE on error and * TRUE if all looks ok. We do not update w_dotline here, as deletes are done * after moves. */ int ldelnewline(void) { struct line *lp1, *lp2, *lp3; struct mgwin *wp; int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read only"); return (FALSE); } lp1 = curwp->w_dotp; lp2 = lp1->l_fp; /* at the end of the buffer */ if (lp2 == curbp->b_headp) return (TRUE); /* Keep line counts in sync */ curwp->w_bufp->b_lines--; if (curwp->w_markline > curwp->w_dotline) curwp->w_markline--; if (lp2->l_used <= lp1->l_size - lp1->l_used) { bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used); for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp2) wp->w_linep = lp1; if (wp->w_dotp == lp2) { wp->w_dotp = lp1; wp->w_doto += lp1->l_used; } if (wp->w_markp == lp2) { wp->w_markp = lp1; wp->w_marko += lp1->l_used; } } lp1->l_used += lp2->l_used; lp1->l_fp = lp2->l_fp; lp2->l_fp->l_bp = lp1; free(lp2); return (TRUE); } if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL) return (FALSE); bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used); bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used); lp1->l_bp->l_fp = lp3; lp3->l_fp = lp2->l_fp; lp2->l_fp->l_bp = lp3; lp3->l_bp = lp1->l_bp; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp1 || wp->w_linep == lp2) wp->w_linep = lp3; if (wp->w_dotp == lp1) wp->w_dotp = lp3; else if (wp->w_dotp == lp2) { wp->w_dotp = lp3; wp->w_doto += lp1->l_used; } if (wp->w_markp == lp1) wp->w_markp = lp3; else if (wp->w_markp == lp2) { wp->w_markp = lp3; wp->w_marko += lp1->l_used; } } free(lp1); free(lp2); return (TRUE); } /* * Replace plen characters before dot with argument string. Control-J * characters in st are interpreted as newlines. There is a casehack * disable flag (normally it likes to match case of replacement to what * was there). */ int lreplace(RSIZE plen, char *st) { RSIZE rlen; /* replacement length */ int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read only"); return (FALSE); } undo_boundary_enable(FFRAND, 0); (void)backchar(FFARG | FFRAND, (int)plen); (void)ldelete(plen, KNONE); rlen = strlen(st); region_put_data(st, rlen); lchange(WFFULL); undo_boundary_enable(FFRAND, 1); return (TRUE); } /* * Allocate and return the supplied line as a C string */ char * linetostr(const struct line *ln) { int len; char *line; len = llength(ln); if (len == INT_MAX) /* (len + 1) overflow */ return (NULL); if ((line = malloc(len + 1)) == NULL) return (NULL); (void)memcpy(line, ltext(ln), len); line[len] = '\0'; return (line); } mg-20161005/macro.c010064400017510001751000000036621276204442100125070ustar00hanboetes/* $OpenBSD: macro.c,v 1.16 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Keyboard macros. */ #include #include #include #include #include "def.h" #include "key.h" #include "macro.h" int inmacro = FALSE; /* Macro playback in progess */ int macrodef = FALSE; /* Macro recording in progress */ int macrocount = 0; struct line *maclhead = NULL; struct line *maclcur; union macrodef macro[MAXMACRO]; /* ARGSUSED */ int definemacro(int f, int n) { struct line *lp1, *lp2; macrocount = 0; if (macrodef) { ewprintf("already defining macro"); return (macrodef = FALSE); } /* free lines allocated for string arguments */ if (maclhead != NULL) { for (lp1 = maclhead->l_fp; lp1 != maclhead; lp1 = lp2) { lp2 = lp1->l_fp; free(lp1); } free(lp1); } if ((maclhead = lp1 = lalloc(0)) == NULL) return (FALSE); ewprintf("Defining Keyboard Macro..."); maclcur = lp1->l_fp = lp1->l_bp = lp1; return (macrodef = TRUE); } /* ARGSUSED */ int finishmacro(int f, int n) { if (macrodef == TRUE) { macrodef = FALSE; ewprintf("End Keyboard Macro Definition"); return (TRUE); } return (FALSE); } /* ARGSUSED */ int executemacro(int f, int n) { int i, j, flag, num; PF funct; if (macrodef || (macrocount >= MAXMACRO && macro[MAXMACRO - 1].m_funct != finishmacro)) { dobeep(); ewprintf("Macro too long. Aborting."); return (FALSE); } if (macrocount == 0) return (TRUE); inmacro = TRUE; for (i = n; i > 0; i--) { maclcur = maclhead->l_fp; flag = 0; num = 1; for (j = 0; j < macrocount - 1; j++) { funct = macro[j].m_funct; if (funct == universal_argument) { flag = FFARG; num = macro[++j].m_count; continue; } if ((*funct)(flag, num) != TRUE) { inmacro = FALSE; return (FALSE); } lastflag = thisflag; thisflag = 0; flag = 0; num = 1; } } inmacro = FALSE; return (TRUE); } mg-20161005/main.c010064400017510001751000000137151277516274500123500ustar00hanboetes/* $OpenBSD: main.c,v 1.84 2016/09/16 17:17:40 tedu Exp $ */ /* This file is in the public domain. */ /* * Mainline. */ #include #include #include #include #include #include #include #include #include #include "def.h" #include "kbd.h" #include "funmap.h" #include "macro.h" int thisflag; /* flags, this command */ int lastflag; /* flags, last command */ int curgoal; /* goal column */ int startrow; /* row to start */ int doaudiblebell; /* audible bell toggle */ int dovisiblebell; /* visible bell toggle */ int dblspace; /* sentence end #spaces */ struct buffer *curbp; /* current buffer */ struct buffer *bheadp; /* BUFFER list head */ struct mgwin *curwp; /* current window */ struct mgwin *wheadp; /* MGWIN listhead */ char pat[NPAT]; /* pattern */ static void edinit(struct buffer *); static __dead void usage(void); extern char *__progname; extern void closetags(void); static __dead void usage() { fprintf(stderr, "usage: %s [-nR] [-f mode] [+number] [file ...]\n", __progname); exit(1); } int main(int argc, char **argv) { char *cp, *init_fcn_name = NULL; PF init_fcn = NULL; int o, i, nfiles; int nobackups = 0, bro = 0; struct buffer *bp = NULL; #if 0 /* Let's make this code ifdef'ed for now. I bet it will take a while * until pledge() comes to other systems. */ if (pledge("stdio rpath wpath cpath fattr chown getpw tty proc exec", NULL) == -1) err(1, "pledge"); #endif while ((o = getopt(argc, argv, "nRf:")) != -1) switch (o) { case 'R': bro = 1; break; case 'n': nobackups = 1; break; case 'f': if (init_fcn_name != NULL) errx(1, "cannot specify more than one " "initial function"); init_fcn_name = optarg; break; default: usage(); } argc -= optind; argv += optind; setlocale(LC_CTYPE, ""); maps_init(); /* Keymaps and modes. */ funmap_init(); /* Functions. */ /* * This is where we initialize standalone extensions that should * be loaded dynamically sometime in the future. */ { extern void grep_init(void); extern void cmode_init(void); extern void dired_init(void); dired_init(); grep_init(); cmode_init(); } if (init_fcn_name && (init_fcn = name_function(init_fcn_name)) == NULL) errx(1, "Unknown function `%s'", init_fcn_name); vtinit(); /* Virtual terminal. */ dirinit(); /* Get current directory. */ edinit(bp); /* Buffers, windows. */ ttykeymapinit(); /* Symbols, bindings. */ bellinit(); /* Audible and visible bell. */ dblspace = 1; /* two spaces for sentence end. */ /* * doing update() before reading files causes the error messages from * the file I/O show up on the screen. (and also an extra display of * the mode line if there are files specified on the command line.) */ update(CMODE); /* user startup file. */ if ((cp = startupfile(NULL)) != NULL) (void)load(cp); /* * Now ensure any default buffer modes from the startup file are * given to any files opened when parsing the startup file. * Note *scratch* will also be updated. */ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { bp->b_flag = defb_flag; for (i = 0; i <= defb_nmodes; i++) { bp->b_modes[i] = defb_modes[i]; } } /* Force FFOTHARG=1 so that this mode is enabled, not simply toggled */ if (init_fcn) init_fcn(FFOTHARG, 1); if (nobackups) makebkfile(FFARG, 0); for (nfiles = 0, i = 0; i < argc; i++) { if (argv[i][0] == '+' && strlen(argv[i]) >= 2) { long long lval; const char *errstr; lval = strtonum(&argv[i][1], INT_MIN, INT_MAX, &errstr); if (argv[i][1] == '\0' || errstr != NULL) goto notnum; startrow = lval; } else { notnum: cp = adjustname(argv[i], FALSE); if (cp != NULL) { if (nfiles == 1) splitwind(0, 1); if (fisdir(cp) == TRUE) { (void)do_dired(cp); continue; } if ((curbp = findbuffer(cp)) == NULL) { vttidy(); errx(1, "Can't find current buffer!"); } (void)showbuffer(curbp, curwp, 0); if (readin(cp) != TRUE) killbuffer(curbp); else { /* Ensure enabled, not just toggled */ if (init_fcn_name) init_fcn(FFOTHARG, 1); nfiles++; } if (bro) curbp->b_flag |= BFREADONLY; } } } if (nfiles > 2) listbuffers(0, 1); /* fake last flags */ thisflag = 0; for (;;) { if (epresf == KCLEAR) eerase(); if (epresf == TRUE) epresf = KCLEAR; if (winch_flag) { do_redraw(0, 0, TRUE); winch_flag = 0; } update(CMODE); lastflag = thisflag; thisflag = 0; switch (doin()) { case TRUE: break; case ABORT: ewprintf("Quit"); /* FALLTHRU */ case FALSE: default: macrodef = FALSE; } } } /* * Initialize default buffer and window. Default buffer is called *scratch*. */ static void edinit(struct buffer *bp) { struct mgwin *wp; bheadp = NULL; bp = bfind("*scratch*", TRUE); /* Text buffer. */ if (bp == NULL) panic("edinit"); wp = new_window(bp); if (wp == NULL) panic("edinit: Out of memory"); curbp = bp; /* Current buffer. */ wheadp = wp; curwp = wp; wp->w_wndp = NULL; /* Initialize window. */ wp->w_linep = wp->w_dotp = bp->b_headp; wp->w_ntrows = nrow - 2; /* 2 = mode, echo. */ wp->w_rflag = WFMODE | WFFULL; /* Full. */ } /* * Quit command. If an argument, always quit. Otherwise confirm if a buffer * has been changed and not written out. Normally bound to "C-X C-C". */ /* ARGSUSED */ int quit(int f, int n) { int s; if ((s = anycb(FALSE)) == ABORT) return (ABORT); if (s == FIOERR || s == UERROR) return (FALSE); if (s == FALSE || eyesno("Modified buffers exist; really exit") == TRUE) { vttidy(); closetags(); exit(0); } return (TRUE); } /* * User abort. Should be called by any input routine that sees a C-g to abort * whatever C-g is aborting these days. Currently does nothing. */ /* ARGSUSED */ int ctrlg(int f, int n) { return (ABORT); } mg-20161005/match.c010064400017510001751000000102161276204442100124730ustar00hanboetes/* $OpenBSD: match.c,v 1.19 2015/06/03 23:40:01 bcallah Exp $ */ /* This file is in the public domain. */ /* * Limited parenthesis matching routines * * The hacks in this file implement automatic matching * of (), [], {}, and * other characters. It would be better to have a full-blown syntax table, * but there's enough overhead in the editor as it is. */ #include #include #include #include "def.h" #include "key.h" static int balance(void); static void displaymatch(struct line *, int); /* * Balance table. When balance() encounters a character that is to be * matched, it first searches this table for a balancing left-side character. * If the character is not in the table, the character is balanced by itself. */ static struct balance { char left, right; } bal[] = { { '(', ')' }, { '[', ']' }, { '{', '}' }, { '<', '>' }, { '\0', '\0' } }; /* * Hack to show matching paren. Self-insert character, then show matching * character, if any. Bound to "blink-and-insert". */ int showmatch(int f, int n) { int i, s; for (i = 0; i < n; i++) { if ((s = selfinsert(FFRAND, 1)) != TRUE) return (s); /* unbalanced -- warn user */ if (balance() != TRUE) dobeep(); } return (TRUE); } /* * Search for and display a matching character. * * This routine does the real work of searching backward * for a balancing character. If such a balancing character * is found, it uses displaymatch() to display the match. */ static int balance(void) { struct line *clp; int cbo; int c, i, depth; int rbal, lbal; rbal = key.k_chars[key.k_count - 1]; /* See if there is a matching character -- default to the same */ lbal = rbal; for (i = 0; bal[i].right != '\0'; i++) if (bal[i].right == rbal) { lbal = bal[i].left; break; } /* * Move behind the inserted character. We are always guaranteed * that there is at least one character on the line. */ clp = curwp->w_dotp; cbo = curwp->w_doto - 1; /* init nesting depth */ depth = 0; for (;;) { if (cbo == 0) { clp = lback(clp); /* beginning of line */ if (clp == curbp->b_headp) return (FALSE); cbo = llength(clp) + 1; } if (--cbo == llength(clp)) c = '\n'; /* end of line */ else c = lgetc(clp, cbo); /* somewhere in middle */ /* * Check for a matching character. If still in a nested * level, pop out of it and continue search. This check * is done before the nesting check so single-character * matches will work too. */ if (c == lbal) { if (depth == 0) { displaymatch(clp, cbo); return (TRUE); } else depth--; } /* Check for another level of nesting. */ if (c == rbal) depth++; } /* NOTREACHED */ } /* * Display matching character. Matching characters that are not in the * current window are displayed in the echo line. If in the current window, * move dot to the matching character, sit there a while, then move back. */ static void displaymatch(struct line *clp, int cbo) { struct line *tlp; int tbo; int cp; int bufo; int c; int inwindow; char buf[NLINE]; /* * Figure out if matching char is in current window by * searching from the top of the window to dot. */ inwindow = FALSE; for (tlp = curwp->w_linep; tlp != lforw(curwp->w_dotp); tlp = lforw(tlp)) if (tlp == clp) inwindow = TRUE; if (inwindow == TRUE) { tlp = curwp->w_dotp; /* save current position */ tbo = curwp->w_doto; curwp->w_dotp = clp; /* move to new position */ curwp->w_doto = cbo; curwp->w_rflag |= WFMOVE; update(CMODE); /* show match */ ttwait(1000); /* wait for key or 1 second */ curwp->w_dotp = tlp; /* return to old position */ curwp->w_doto = tbo; curwp->w_rflag |= WFMOVE; update(CMODE); } else { /* match is not in this window, so display line in echo area */ bufo = 0; for (cp = 0; cp < llength(clp); cp++) { c = lgetc(clp, cp); if (c != '\t' #ifdef NOTAB || (curbp->b_flag & BFNOTAB) #endif ) if (ISCTRL(c)) { buf[bufo++] = '^'; buf[bufo++] = CCHR(c); } else buf[bufo++] = c; else do { buf[bufo++] = ' '; } while (bufo & 7); } buf[bufo++] = '\0'; ewprintf("Matches %s", buf); } } mg-20161005/modes.c010064400017510001751000000067321276204442100125160ustar00hanboetes/* $OpenBSD: modes.c,v 1.20 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Commands to toggle modes. Without an argument, these functions will * toggle the given mode. A negative or zero argument will turn the mode * off. A positive argument will turn the mode on. */ #include #include #include #include #include "def.h" #include "kbd.h" int changemode(int, int, char *); int defb_nmodes = 0; struct maps_s *defb_modes[PBMODES] = { &fundamental_mode }; int defb_flag = 0; int changemode(int f, int n, char *mode) { int i; struct maps_s *m; if ((m = name_mode(mode)) == NULL) { dobeep(); ewprintf("Can't find mode %s", mode); return (FALSE); } if (!(f & FFARG)) { for (i = 0; i <= curbp->b_nmodes; i++) if (curbp->b_modes[i] == m) { /* mode already set */ n = 0; break; } } if (n > 0) { for (i = 0; i <= curbp->b_nmodes; i++) if (curbp->b_modes[i] == m) /* mode already set */ return (TRUE); if (curbp->b_nmodes >= PBMODES - 1) { dobeep(); ewprintf("Too many modes"); return (FALSE); } curbp->b_modes[++(curbp->b_nmodes)] = m; } else { /* fundamental is b_modes[0] and can't be unset */ for (i = 1; i <= curbp->b_nmodes && m != curbp->b_modes[i]; i++); if (i > curbp->b_nmodes) return (TRUE); /* mode wasn't set */ for (; i < curbp->b_nmodes; i++) curbp->b_modes[i] = curbp->b_modes[i + 1]; curbp->b_nmodes--; } upmodes(curbp); return (TRUE); } int indentmode(int f, int n) { return (changemode(f, n, "indent")); } int fillmode(int f, int n) { return (changemode(f, n, "fill")); } #ifdef NOTAB int notabmode(int f, int n) { if (changemode(f, n, "notab") == FALSE) return (FALSE); if (f & FFARG) { if (n <= 0) curbp->b_flag &= ~BFNOTAB; else curbp->b_flag |= BFNOTAB; } else curbp->b_flag ^= BFNOTAB; return (TRUE); } #endif /* NOTAB */ int overwrite_mode(int f, int n) { if (changemode(f, n, "overwrite") == FALSE) return (FALSE); if (f & FFARG) { if (n <= 0) curbp->b_flag &= ~BFOVERWRITE; else curbp->b_flag |= BFOVERWRITE; } else curbp->b_flag ^= BFOVERWRITE; return (TRUE); } int set_default_mode(int f, int n) { int i; struct maps_s *m; char modebuf[32], *bufp; if ((bufp = eread("Set Default Mode: ", modebuf, sizeof(modebuf), EFNEW)) == NULL) return (ABORT); else if (bufp[0] == '\0') return (FALSE); if ((m = name_mode(modebuf)) == NULL) { dobeep(); ewprintf("can't find mode %s", modebuf); return (FALSE); } if (!(f & FFARG)) { for (i = 0; i <= defb_nmodes; i++) if (defb_modes[i] == m) { /* mode already set */ n = 0; break; } } if (n > 0) { for (i = 0; i <= defb_nmodes; i++) if (defb_modes[i] == m) /* mode already set */ return (TRUE); if (defb_nmodes >= PBMODES - 1) { dobeep(); ewprintf("Too many modes"); return (FALSE); } defb_modes[++defb_nmodes] = m; } else { /* fundamental is defb_modes[0] and can't be unset */ for (i = 1; i <= defb_nmodes && m != defb_modes[i]; i++); if (i > defb_nmodes) /* mode was not set */ return (TRUE); for (; i < defb_nmodes; i++) defb_modes[i] = defb_modes[i + 1]; defb_nmodes--; } if (strcmp(modebuf, "overwrite") == 0) { if (n <= 0) defb_flag &= ~BFOVERWRITE; else defb_flag |= BFOVERWRITE; } #ifdef NOTAB if (strcmp(modebuf, "notab") == 0) { if (n <= 0) defb_flag &= ~BFNOTAB; else defb_flag |= BFNOTAB; } #endif /* NOTAB */ return (TRUE); } mg-20161005/paragraph.c010064400017510001751000000252031276555461200133610ustar00hanboetes/* $OpenBSD: paragraph.c,v 1.45 2016/09/06 16:25:47 lum Exp $ */ /* This file is in the public domain. */ /* * Code for dealing with paragraphs and filling. Adapted from MicroEMACS 3.6 * and GNU-ified by mwm@ucbvax. Several bug fixes by blarson@usc-oberon. */ #include #include #include #include #include #include #include "def.h" static int fillcol = 70; #define MAXWORD 256 static int findpara(void); static int do_gotoeop(int, int, int *); /* * Move to start of paragraph. * Move backwards by line, checking from the 1st character forwards for the * existence a non-space. If a non-space character is found, move to the * preceding line. Keep doing this until a line with only spaces is found or * the start of buffer. */ /* ARGSUSED */ int gotobop(int f, int n) { int col, nospace; /* the other way... */ if (n < 0) return (gotoeop(f, -n)); while (n-- > 0) { nospace = 0; while (lback(curwp->w_dotp) != curbp->b_headp) { curwp->w_doto = 0; col = 0; while (col < llength(curwp->w_dotp) && (isspace(lgetc(curwp->w_dotp, col)))) col++; if (col >= llength(curwp->w_dotp)) { if (nospace) break; } else nospace = 1; curwp->w_dotline--; curwp->w_dotp = lback(curwp->w_dotp); } } /* force screen update */ curwp->w_rflag |= WFMOVE; return (TRUE); } /* * Move to end of paragraph. * See comments for gotobop(). Same, but moving forwards. */ /* ARGSUSED */ int gotoeop(int f, int n) { int i; return(do_gotoeop(f, n, &i)); } int do_gotoeop(int f, int n, int *i) { int col, nospace, j = 0; /* the other way... */ if (n < 0) return (gotobop(f, -n)); /* for each one asked for */ while (n-- > 0) { *i = ++j; nospace = 0; while (lforw(curwp->w_dotp) != curbp->b_headp) { col = 0; curwp->w_doto = 0; while (col < llength(curwp->w_dotp) && (isspace(lgetc(curwp->w_dotp, col)))) col++; if (col >= llength(curwp->w_dotp)) { if (nospace) break; } else nospace = 1; curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_dotline++; } } /* do not continue after end of buffer */ if (lforw(curwp->w_dotp) == curbp->b_headp) { gotoeol(FFRAND, 1); curwp->w_rflag |= WFMOVE; return (FALSE); } /* force screen update */ curwp->w_rflag |= WFMOVE; return (TRUE); } /* * Justify a paragraph. Fill the current paragraph according to the current * fill column. */ /* ARGSUSED */ int fillpara(int f, int n) { int c; /* current char during scan */ int wordlen; /* length of current word */ int clength; /* position on line during fill */ int i; /* index during word copy */ int eopflag; /* Are we at the End-Of-Paragraph? */ int firstflag; /* first word? (needs no space) */ int newlength; /* tentative new line length */ int eolflag; /* was at end of line */ int retval; /* return value */ struct line *eopline; /* pointer to line just past EOP */ char wbuf[MAXWORD]; /* buffer for current word */ if (n == 0) return (TRUE); undo_boundary_enable(FFRAND, 0); /* record the pointer to the line just past the EOP */ (void)gotoeop(FFRAND, 1); if (curwp->w_doto != 0) { /* paragraph ends at end of buffer */ (void)lnewline(); eopline = lforw(curwp->w_dotp); } else eopline = curwp->w_dotp; /* and back top the beginning of the paragraph */ (void)gotobop(FFRAND, 1); /* initialize various info */ while (inword() == 0 && forwchar(FFRAND, 1)); clength = curwp->w_doto; wordlen = 0; /* scan through lines, filling words */ firstflag = TRUE; eopflag = FALSE; while (!eopflag) { /* get the next character in the paragraph */ if ((eolflag = (curwp->w_doto == llength(curwp->w_dotp)))) { c = ' '; if (lforw(curwp->w_dotp) == eopline) eopflag = TRUE; } else c = lgetc(curwp->w_dotp, curwp->w_doto); /* and then delete it */ if (ldelete((RSIZE) 1, KNONE) == FALSE && !eopflag) { retval = FALSE; goto cleanup; } /* if not a separator, just add it in */ if (c != ' ' && c != '\t') { if (wordlen < MAXWORD - 1) wbuf[wordlen++] = c; else { /* * You lose chars beyond MAXWORD if the word * is too long. I'm too lazy to fix it now; it * just silently truncated the word before, * so I get to feel smug. */ ewprintf("Word too long!"); } } else if (wordlen) { /* calculate tentative new length with word added */ newlength = clength + 1 + wordlen; /* * if at end of line or at doublespace and previous * character was one of '.','?','!' doublespace here. * behave the same way if a ')' is preceded by a * [.?!] and followed by a doublespace. */ if (dblspace && (!eopflag && ((eolflag || curwp->w_doto == llength(curwp->w_dotp) || (c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || c == '\t') && (ISEOSP(wbuf[wordlen - 1]) || (wbuf[wordlen - 1] == ')' && wordlen >= 2 && ISEOSP(wbuf[wordlen - 2])))) && wordlen < MAXWORD - 1)) wbuf[wordlen++] = ' '; /* at a word break with a word waiting */ if (newlength <= fillcol) { /* add word to current line */ if (!firstflag) { (void)linsert(1, ' '); ++clength; } firstflag = FALSE; } else { if (curwp->w_doto > 0 && lgetc(curwp->w_dotp, curwp->w_doto - 1) == ' ') { curwp->w_doto -= 1; (void)ldelete((RSIZE) 1, KNONE); } /* start a new line */ (void)lnewline(); clength = 0; } /* and add the word in in either case */ for (i = 0; i < wordlen; i++) { (void)linsert(1, wbuf[i]); ++clength; } wordlen = 0; } } /* and add a last newline for the end of our new paragraph */ (void)lnewline(); /* * We really should wind up where we started, (which is hard to keep * track of) but I think the end of the last line is better than the * beginning of the blank line. */ (void)backchar(FFRAND, 1); retval = TRUE; cleanup: undo_boundary_enable(FFRAND, 1); return (retval); } /* * Delete n paragraphs. Move to the beginning of the current paragraph, or if * the cursor is on an empty line, move down the buffer to the first line with * non-space characters. Then mark n paragraphs and delete. */ /* ARGSUSED */ int killpara(int f, int n) { int lineno, status; if (n == 0) return (TRUE); if (findpara() == FALSE) return (TRUE); /* go to the beginning of the paragraph */ (void)gotobop(FFRAND, 1); /* take a note of the line number for after deletions and set mark */ lineno = curwp->w_dotline; curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; (void)gotoeop(FFRAND, n); if ((status = killregion(FFRAND, 1)) != TRUE) return (status); curwp->w_dotline = lineno; return (TRUE); } /* * Mark n paragraphs starting with the n'th and working our way backwards. * This leaves the cursor at the beginning of the paragraph where markpara() * was invoked. */ /* ARGSUSED */ int markpara(int f, int n) { int i = 0; if (n == 0) return (TRUE); clearmark(FFARG, 0); if (findpara() == FALSE) return (TRUE); (void)do_gotoeop(FFRAND, n, &i); /* set the mark here */ curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; (void)gotobop(FFRAND, i); return (TRUE); } /* * Transpose the current paragraph with the following paragraph. If invoked * multiple times, transpose to the n'th paragraph. If invoked between * paragraphs, move to the previous paragraph, then continue. */ /* ARGSUSED */ int transposepara(int f, int n) { int i = 0, status; char flg; if (n == 0) return (TRUE); /* find a paragraph, set mark, then goto the end */ gotobop(FFRAND, 1); curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; (void)gotoeop(FFRAND, 1); /* take a note of buffer flags - we may need them */ flg = curbp->b_flag; /* clean out kill buffer then kill region */ kdelete(); if ((status = killregion(FFRAND, 1)) != TRUE) return (status); /* * Now step through n paragraphs. If we reach the end of buffer, * stop and paste the killed region back, then display a message. */ if (do_gotoeop(FFRAND, n, &i) == FALSE) { ewprintf("Cannot transpose paragraph, end of buffer reached."); (void)gotobop(FFRAND, i); (void)yank(FFRAND, 1); curbp->b_flag = flg; return (FALSE); } (void)yank(FFRAND, 1); return (TRUE); } /* * Go down the buffer until we find a line with non-space characters. */ int findpara(void) { int col, nospace = 0; /* we move forward to find a para to mark */ do { curwp->w_doto = 0; col = 0; /* check if we are on a blank line */ while (col < llength(curwp->w_dotp)) { if (!isspace(lgetc(curwp->w_dotp, col))) nospace = 1; col++; } if (nospace) break; if (lforw(curwp->w_dotp) == curbp->b_headp) return (FALSE); curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_dotline++; } while (1); return (TRUE); } /* * Insert char with work wrap. Check to see if we're past fillcol, and if so, * justify this line. As a last step, justify the line. */ /* ARGSUSED */ int fillword(int f, int n) { char c; int col, i, nce; for (i = col = 0; col <= fillcol; ++i, ++col) { if (i == curwp->w_doto) return selfinsert(f, n); c = lgetc(curwp->w_dotp, i); if (c == '\t' #ifdef NOTAB && !(curbp->b_flag & BFNOTAB) #endif ) col |= 0x07; else if (ISCTRL(c) != FALSE) ++col; } if (curwp->w_doto != llength(curwp->w_dotp)) { (void)selfinsert(f, n); nce = llength(curwp->w_dotp) - curwp->w_doto; } else nce = 0; curwp->w_doto = i; if ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' && c != '\t') do { (void)backchar(FFRAND, 1); } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' && c != '\t' && curwp->w_doto > 0); if (curwp->w_doto == 0) do { (void)forwchar(FFRAND, 1); } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' && c != '\t' && curwp->w_doto < llength(curwp->w_dotp)); (void)delwhite(FFRAND, 1); (void)lnewline(); i = llength(curwp->w_dotp) - nce; curwp->w_doto = i > 0 ? i : 0; curwp->w_rflag |= WFMOVE; if (nce == 0 && curwp->w_doto != 0) return (fillword(f, n)); return (TRUE); } /* * Set fill column to n for justify. */ int setfillcol(int f, int n) { char buf[32], *rep; const char *es; int nfill; if ((f & FFARG) != 0) { fillcol = n; } else { if ((rep = eread("Set fill-column: ", buf, sizeof(buf), EFNEW | EFCR)) == NULL) return (ABORT); else if (rep[0] == '\0') return (FALSE); nfill = strtonum(rep, 0, INT_MAX, &es); if (es != NULL) { dobeep(); ewprintf("Invalid fill column: %s", rep); return (FALSE); } fillcol = nfill; ewprintf("Fill column set to %d", fillcol); } return (TRUE); } int sentencespace(int f, int n) { if (f & FFARG) dblspace = n > 1; else dblspace = !dblspace; return (TRUE); } mg-20161005/re_search.c010064400017510001751000000337461276204442100133470ustar00hanboetes/* $OpenBSD: re_search.c,v 1.31 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * regular expression search commands for Mg * * This file contains functions to implement several of gnuemacs's regular * expression functions for Mg. Several of the routines below are just minor * re-arrangements of Mg's non-regular expression search functions. Some of * them are similar in structure to the original MicroEMACS, others are * modifications of Rich Ellison's code. Peter Newton re-wrote about half of * them from scratch. */ #ifdef REGEX #include #include #include #include #include #include #include "def.h" #include "macro.h" #define SRCH_BEGIN (0) /* search sub-codes */ #define SRCH_FORW (-1) #define SRCH_BACK (-2) #define SRCH_NOPR (-3) #define SRCH_ACCM (-4) #define SRCH_MARK (-5) #define RE_NMATCH 10 /* max number of matches */ #define REPLEN 256 /* max length of replacement string */ char re_pat[NPAT]; /* regex pattern */ int re_srch_lastdir = SRCH_NOPR; /* last search flags */ int casefoldsearch = TRUE; /* does search ignore case? */ static int re_doreplace(RSIZE, char *); static int re_forwsrch(void); static int re_backsrch(void); static int re_readpattern(char *); static int killmatches(int); static int countmatches(int); /* * Search forward. * Get a search string from the user and search for it starting at ".". If * found, move "." to just after the matched characters. display does all * the hard stuff. If not found, it just prints a message. */ /* ARGSUSED */ int re_forwsearch(int f, int n) { int s; if ((s = re_readpattern("RE Search")) != TRUE) return (s); if (re_forwsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", re_pat); return (FALSE); } re_srch_lastdir = SRCH_FORW; return (TRUE); } /* * Reverse search. * Get a search string from the user, and search, starting at "." * and proceeding toward the front of the buffer. If found "." is left * pointing at the first character of the pattern [the last character that * was matched]. */ /* ARGSUSED */ int re_backsearch(int f, int n) { int s; if ((s = re_readpattern("RE Search backward")) != TRUE) return (s); if (re_backsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", re_pat); return (FALSE); } re_srch_lastdir = SRCH_BACK; return (TRUE); } /* * Search again, using the same search string and direction as the last search * command. The direction has been saved in "srch_lastdir", so you know which * way to go. * * XXX: This code has problems -- some incompatibility(?) with extend.c causes * match to fail when it should not. */ /* ARGSUSED */ int re_searchagain(int f, int n) { if (re_srch_lastdir == SRCH_NOPR) { dobeep(); ewprintf("No last search"); return (FALSE); } if (re_srch_lastdir == SRCH_FORW) { if (re_forwsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", re_pat); return (FALSE); } return (TRUE); } if (re_srch_lastdir == SRCH_BACK) if (re_backsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", re_pat); return (FALSE); } return (TRUE); } /* Compiled regex goes here-- changed only when new pattern read */ static regex_t regex_buff; static regmatch_t regex_match[RE_NMATCH]; /* * Re-Query Replace. * Replace strings selectively. Does a search and replace operation. */ /* ARGSUSED */ int re_queryrepl(int f, int n) { int rcnt = 0; /* replacements made so far */ int plen, s; /* length of found string */ char news[NPAT]; /* replacement string */ if ((s = re_readpattern("RE Query replace")) != TRUE) return (s); if (eread("Query replace %s with: ", news, NPAT, EFNUL | EFNEW | EFCR, re_pat) == NULL) return (ABORT); ewprintf("Query replacing %s with %s:", re_pat, news); /* * Search forward repeatedly, checking each time whether to insert * or not. The "!" case makes the check always true, so it gets put * into a tighter loop for efficiency. */ while (re_forwsrch() == TRUE) { retry: update(CMODE); switch (getkey(FALSE)) { case ' ': plen = regex_match[0].rm_eo - regex_match[0].rm_so; if (re_doreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; break; case '.': plen = regex_match[0].rm_eo - regex_match[0].rm_so; if (re_doreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; goto stopsearch; case CCHR('G'): /* ^G */ (void)ctrlg(FFRAND, 0); goto stopsearch; case CCHR('['): /* ESC */ case '`': goto stopsearch; case '!': do { plen = regex_match[0].rm_eo - regex_match[0].rm_so; if (re_doreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; } while (re_forwsrch() == TRUE); goto stopsearch; case CCHR('?'): /* To not replace */ break; default: ewprintf(" replace, [.] rep-end, don't, [!] repl rest quit"); goto retry; } } stopsearch: curwp->w_rflag |= WFFULL; update(CMODE); if (!inmacro) { if (rcnt == 0) ewprintf("(No replacements done)"); else if (rcnt == 1) ewprintf("(1 replacement done)"); else ewprintf("(%d replacements done)", rcnt); } return (TRUE); } /* * Routine re_doreplace calls lreplace to make replacements needed by * re_query replace. Its reason for existence is to deal with \1, \2. etc. * plen: length to remove * st: replacement string */ static int re_doreplace(RSIZE plen, char *st) { int j, k, s, more, num, state; struct line *clp; char repstr[REPLEN]; clp = curwp->w_dotp; more = TRUE; j = 0; state = 0; num = 0; /* The following FSA parses the replacement string */ while (more) { switch (state) { case 0: if (*st == '\\') { st++; state = 1; } else if (*st == '\0') more = FALSE; else { repstr[j] = *st; j++; if (j >= REPLEN) return (FALSE); st++; } break; case 1: if (*st >= '0' && *st <= '9') { num = *st - '0'; st++; state = 2; } else if (*st == '\0') more = FALSE; else { repstr[j] = *st; j++; if (j >= REPLEN) return (FALSE); st++; state = 0; } break; case 2: if (*st >= '0' && *st <= '9') { num = 10 * num + *st - '0'; st++; } else { if (num >= RE_NMATCH) return (FALSE); k = regex_match[num].rm_eo - regex_match[num].rm_so; if (j + k >= REPLEN) return (FALSE); bcopy(&(clp->l_text[regex_match[num].rm_so]), &repstr[j], k); j += k; if (*st == '\0') more = FALSE; if (*st == '\\') { st++; state = 1; } else { repstr[j] = *st; j++; if (j >= REPLEN) return (FALSE); st++; state = 0; } } break; } /* switch (state) */ } /* while (more) */ repstr[j] = '\0'; s = lreplace(plen, repstr); return (s); } /* * This routine does the real work of a forward search. The pattern is * sitting in the external variable "pat". If found, dot is updated, the * window system is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ static int re_forwsrch(void) { int tbo, tdotline, error; struct line *clp; clp = curwp->w_dotp; tbo = curwp->w_doto; tdotline = curwp->w_dotline; if (tbo == clp->l_used) /* * Don't start matching past end of line -- must move to * beginning of next line, unless at end of file. */ if (clp != curbp->b_headp) { clp = lforw(clp); tdotline++; tbo = 0; } /* * Note this loop does not process the last line, but this editor * always makes the last line empty so this is good. */ while (clp != (curbp->b_headp)) { regex_match[0].rm_so = tbo; regex_match[0].rm_eo = llength(clp); error = regexec(®ex_buff, ltext(clp), RE_NMATCH, regex_match, REG_STARTEND); if (error != 0) { clp = lforw(clp); tdotline++; tbo = 0; } else { curwp->w_doto = regex_match[0].rm_eo; curwp->w_dotp = clp; curwp->w_dotline = tdotline; curwp->w_rflag |= WFMOVE; return (TRUE); } } return (FALSE); } /* * This routine does the real work of a backward search. The pattern is sitting * in the external variable "re_pat". If found, dot is updated, the window * system is notified of the change, and TRUE is returned. If the string isn't * found, FALSE is returned. */ static int re_backsrch(void) { struct line *clp; int tbo, tdotline; regmatch_t lastmatch; clp = curwp->w_dotp; tbo = curwp->w_doto; tdotline = curwp->w_dotline; /* Start search one position to the left of dot */ tbo = tbo - 1; if (tbo < 0) { /* must move up one line */ clp = lback(clp); tdotline--; tbo = llength(clp); } /* * Note this loop does not process the last line, but this editor * always makes the last line empty so this is good. */ while (clp != (curbp->b_headp)) { regex_match[0].rm_so = 0; regex_match[0].rm_eo = llength(clp); lastmatch.rm_so = -1; /* * Keep searching until we don't match any longer. Assumes a * non-match does not modify the regex_match array. We have to * do this character-by-character after the first match since * POSIX regexps don't give you a way to do reverse matches. */ while (!regexec(®ex_buff, ltext(clp), RE_NMATCH, regex_match, REG_STARTEND) && regex_match[0].rm_so < tbo) { memcpy(&lastmatch, ®ex_match[0], sizeof(regmatch_t)); regex_match[0].rm_so++; regex_match[0].rm_eo = llength(clp); } if (lastmatch.rm_so == -1) { clp = lback(clp); tdotline--; tbo = llength(clp); } else { memcpy(®ex_match[0], &lastmatch, sizeof(regmatch_t)); curwp->w_doto = regex_match[0].rm_so; curwp->w_dotp = clp; curwp->w_dotline = tdotline; curwp->w_rflag |= WFMOVE; return (TRUE); } } return (FALSE); } /* * Read a pattern. * Stash it in the external variable "re_pat". The "pat" is * not updated if the user types in an empty line. If the user typed * an empty line, and there is no old pattern, it is an error. * Display the old pattern, in the style of Jeff Lomicka. There is * some do-it-yourself control expansion. */ static int re_readpattern(char *prompt) { static int dofree = 0; int flags, error, s; char tpat[NPAT], *rep; if (re_pat[0] == '\0') rep = eread("%s: ", tpat, NPAT, EFNEW | EFCR, prompt); else rep = eread("%s: (default %s) ", tpat, NPAT, EFNUL | EFNEW | EFCR, prompt, re_pat); if (rep == NULL) return (ABORT); if (rep[0] != '\0') { /* New pattern given */ (void)strlcpy(re_pat, tpat, sizeof(re_pat)); if (casefoldsearch) flags = REG_EXTENDED | REG_ICASE; else flags = REG_EXTENDED; if (dofree) regfree(®ex_buff); error = regcomp(®ex_buff, re_pat, flags); if (error != 0) { char message[256]; regerror(error, ®ex_buff, message, sizeof(message)); dobeep(); ewprintf("Regex Error: %s", message); re_pat[0] = '\0'; return (FALSE); } dofree = 1; s = TRUE; } else if (rep[0] == '\0' && re_pat[0] != '\0') /* Just using old pattern */ s = TRUE; else s = FALSE; return (s); } /* * Cause case to not matter in searches. This is the default. If called * with argument cause case to matter. */ /* ARGSUSED*/ int setcasefold(int f, int n) { if (f & FFARG) { casefoldsearch = FALSE; ewprintf("Case-fold-search unset"); } else { casefoldsearch = TRUE; ewprintf("Case-fold-search set"); } /* * Invalidate the regular expression pattern since I'm too lazy to * recompile it. */ re_pat[0] = '\0'; return (TRUE); } /* * Delete all lines after dot that contain a string matching regex. */ /* ARGSUSED */ int delmatchlines(int f, int n) { int s; if ((s = re_readpattern("Flush lines (containing match for regexp)")) != TRUE) return (s); s = killmatches(TRUE); return (s); } /* * Delete all lines after dot that don't contain a string matching regex. */ /* ARGSUSED */ int delnonmatchlines(int f, int n) { int s; if ((s = re_readpattern("Keep lines (containing match for regexp)")) != TRUE) return (s); s = killmatches(FALSE); return (s); } /* * This function does the work of deleting matching lines. */ static int killmatches(int cond) { int s, error; int count = 0; struct line *clp; clp = curwp->w_dotp; if (curwp->w_doto == llength(clp)) /* Consider dot on next line */ clp = lforw(clp); while (clp != (curbp->b_headp)) { /* see if line matches */ regex_match[0].rm_so = 0; regex_match[0].rm_eo = llength(clp); error = regexec(®ex_buff, ltext(clp), RE_NMATCH, regex_match, REG_STARTEND); /* Delete line when appropriate */ if ((cond == FALSE && error) || (cond == TRUE && !error)) { curwp->w_doto = 0; curwp->w_dotp = clp; count++; s = ldelete(llength(clp) + 1, KNONE); clp = curwp->w_dotp; curwp->w_rflag |= WFMOVE; if (s == FALSE) return (FALSE); } else clp = lforw(clp); } ewprintf("%d line(s) deleted", count); if (count > 0) curwp->w_rflag |= WFMOVE; return (TRUE); } /* * Count lines matching regex. */ /* ARGSUSED */ int cntmatchlines(int f, int n) { int s; if ((s = re_readpattern("Count lines (matching regexp)")) != TRUE) return (s); s = countmatches(TRUE); return (s); } /* * Count lines that fail to match regex. */ /* ARGSUSED */ int cntnonmatchlines(int f, int n) { int s; if ((s = re_readpattern("Count lines (not matching regexp)")) != TRUE) return (s); s = countmatches(FALSE); return (s); } /* * This function does the work of counting matching lines. */ int countmatches(int cond) { int error; int count = 0; struct line *clp; clp = curwp->w_dotp; if (curwp->w_doto == llength(clp)) /* Consider dot on next line */ clp = lforw(clp); while (clp != (curbp->b_headp)) { /* see if line matches */ regex_match[0].rm_so = 0; regex_match[0].rm_eo = llength(clp); error = regexec(®ex_buff, ltext(clp), RE_NMATCH, regex_match, REG_STARTEND); /* Count line when appropriate */ if ((cond == FALSE && error) || (cond == TRUE && !error)) count++; clp = lforw(clp); } if (cond) ewprintf("Number of lines matching: %d", count); else ewprintf("Number of lines not matching: %d", count); return (TRUE); } #endif /* REGEX */ mg-20161005/region.c010064400017510001751000000352401276555461200127010ustar00hanboetes/* $OpenBSD: region.c,v 1.37 2016/09/09 06:05:51 lum Exp $ */ /* This file is in the public domain. */ /* * Region based commands. * The routines in this file deal with the region, that magic space between * "." and mark. Some functions are commands. Some functions are just for * internal use. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "def.h" #define TIMEOUT 10000 static char leftover[BUFSIZ]; static int getregion(struct region *); static int iomux(int, char * const, int, struct buffer *); static int preadin(int, struct buffer *); static void pwriteout(int, char **, int *); static int setsize(struct region *, RSIZE); static int shellcmdoutput(char * const[], char * const, int); /* * Kill the region. Ask "getregion" to figure out the bounds of the region. * Move "." to the start, and kill the characters. Mark is cleared afterwards. */ /* ARGSUSED */ int killregion(int f, int n) { int s; struct region region; if ((s = getregion(®ion)) != TRUE) return (s); /* This is a kill-type command, so do magic kill buffer stuff. */ if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; curwp->w_dotp = region.r_linep; curwp->w_doto = region.r_offset; curwp->w_dotline = region.r_lineno; s = ldelete(region.r_size, KFORW | KREG); clearmark(FFARG, 0); return (s); } /* * Copy all of the characters in the region to the kill buffer, * clearing the mark afterwards. * This is a bit like a kill region followed by a yank. */ /* ARGSUSED */ int copyregion(int f, int n) { struct line *linep; struct region region; int loffs; int s; if ((s = getregion(®ion)) != TRUE) return (s); /* kill type command */ if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; /* current line */ linep = region.r_linep; /* current offset */ loffs = region.r_offset; while (region.r_size--) { if (loffs == llength(linep)) { /* End of line. */ if ((s = kinsert('\n', KFORW)) != TRUE) return (s); linep = lforw(linep); loffs = 0; } else { /* Middle of line. */ if ((s = kinsert(lgetc(linep, loffs), KFORW)) != TRUE) return (s); ++loffs; } } clearmark(FFARG, 0); return (TRUE); } /* * Lower case region. Zap all of the upper case characters in the region to * lower case. Use the region code to set the limits. Scan the buffer, doing * the changes. Call "lchange" to ensure that redisplay is done in all * buffers. */ /* ARGSUSED */ int lowerregion(int f, int n) { struct line *linep; struct region region; int loffs, c, s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if ((s = getregion(®ion)) != TRUE) return (s); undo_add_change(region.r_linep, region.r_offset, region.r_size); lchange(WFFULL); linep = region.r_linep; loffs = region.r_offset; while (region.r_size--) { if (loffs == llength(linep)) { linep = lforw(linep); loffs = 0; } else { c = lgetc(linep, loffs); if (ISUPPER(c) != FALSE) lputc(linep, loffs, TOLOWER(c)); ++loffs; } } return (TRUE); } /* * Upper case region. Zap all of the lower case characters in the region to * upper case. Use the region code to set the limits. Scan the buffer, * doing the changes. Call "lchange" to ensure that redisplay is done in all * buffers. */ /* ARGSUSED */ int upperregion(int f, int n) { struct line *linep; struct region region; int loffs, c, s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if ((s = getregion(®ion)) != TRUE) return (s); undo_add_change(region.r_linep, region.r_offset, region.r_size); lchange(WFFULL); linep = region.r_linep; loffs = region.r_offset; while (region.r_size--) { if (loffs == llength(linep)) { linep = lforw(linep); loffs = 0; } else { c = lgetc(linep, loffs); if (ISLOWER(c) != FALSE) lputc(linep, loffs, TOUPPER(c)); ++loffs; } } return (TRUE); } /* * This routine figures out the bound of the region in the current window, * and stores the results into the fields of the REGION structure. Dot and * mark are usually close together, but I don't know the order, so I scan * outward from dot, in both directions, looking for mark. The size is kept * in a long. At the end, after the size is figured out, it is assigned to * the size field of the region structure. If this assignment loses any bits, * then we print an error. This is "type independent" overflow checking. All * of the callers of this routine should be ready to get an ABORT status, * because I might add a "if regions is big, ask before clobbering" flag. */ static int getregion(struct region *rp) { struct line *flp, *blp; long fsize, bsize; if (curwp->w_markp == NULL) { dobeep(); ewprintf("No mark set in this window"); return (FALSE); } /* "r_size" always ok */ if (curwp->w_dotp == curwp->w_markp) { rp->r_linep = curwp->w_dotp; rp->r_lineno = curwp->w_dotline; if (curwp->w_doto < curwp->w_marko) { rp->r_offset = curwp->w_doto; rp->r_size = (RSIZE)(curwp->w_marko - curwp->w_doto); } else { rp->r_offset = curwp->w_marko; rp->r_size = (RSIZE)(curwp->w_doto - curwp->w_marko); } return (TRUE); } /* get region size */ flp = blp = curwp->w_dotp; bsize = curwp->w_doto; fsize = llength(flp) - curwp->w_doto + 1; while (lforw(flp) != curbp->b_headp || lback(blp) != curbp->b_headp) { if (lforw(flp) != curbp->b_headp) { flp = lforw(flp); if (flp == curwp->w_markp) { rp->r_linep = curwp->w_dotp; rp->r_offset = curwp->w_doto; rp->r_lineno = curwp->w_dotline; return (setsize(rp, (RSIZE)(fsize + curwp->w_marko))); } fsize += llength(flp) + 1; } if (lback(blp) != curbp->b_headp) { blp = lback(blp); bsize += llength(blp) + 1; if (blp == curwp->w_markp) { rp->r_linep = blp; rp->r_offset = curwp->w_marko; rp->r_lineno = curwp->w_markline; return (setsize(rp, (RSIZE)(bsize - curwp->w_marko))); } } } dobeep(); ewprintf("Bug: lost mark"); return (FALSE); } /* * Set size, and check for overflow. */ static int setsize(struct region *rp, RSIZE size) { rp->r_size = size; if (rp->r_size != size) { dobeep(); ewprintf("Region is too large"); return (FALSE); } return (TRUE); } #define PREFIXLENGTH 40 static char prefix_string[PREFIXLENGTH] = {'>', '\0'}; /* * Prefix the region with whatever is in prefix_string. Leaves dot at the * beginning of the line after the end of the region. If an argument is * given, prompts for the line prefix string. */ /* ARGSUSED */ int prefixregion(int f, int n) { struct line *first, *last; struct region region; char *prefix = prefix_string; int nline; int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if ((f == TRUE) && ((s = setprefix(FFRAND, 1)) != TRUE)) return (s); /* get # of lines to affect */ if ((s = getregion(®ion)) != TRUE) return (s); first = region.r_linep; last = (first == curwp->w_dotp) ? curwp->w_markp : curwp->w_dotp; for (nline = 1; first != last; nline++) first = lforw(first); /* move to beginning of region */ curwp->w_dotp = region.r_linep; curwp->w_doto = region.r_offset; curwp->w_dotline = region.r_lineno; /* for each line, go to beginning and insert the prefix string */ while (nline--) { (void)gotobol(FFRAND, 1); for (prefix = prefix_string; *prefix; prefix++) (void)linsert(1, *prefix); (void)forwline(FFRAND, 1); } (void)gotobol(FFRAND, 1); return (TRUE); } /* * Set line prefix string. Used by prefixregion. */ /* ARGSUSED */ int setprefix(int f, int n) { char buf[PREFIXLENGTH], *rep; int retval; if (prefix_string[0] == '\0') rep = eread("Prefix string: ", buf, sizeof(buf), EFNEW | EFCR); else rep = eread("Prefix string (default %s): ", buf, sizeof(buf), EFNUL | EFNEW | EFCR, prefix_string); if (rep == NULL) return (ABORT); if (rep[0] != '\0') { (void)strlcpy(prefix_string, rep, sizeof(prefix_string)); retval = TRUE; } else if (rep[0] == '\0' && prefix_string[0] != '\0') { /* CR -- use old one */ retval = TRUE; } else retval = FALSE; return (retval); } int region_get_data(struct region *reg, char *buf, int len) { int i, off; struct line *lp; off = reg->r_offset; lp = reg->r_linep; for (i = 0; i < len; i++) { if (off == llength(lp)) { lp = lforw(lp); if (lp == curbp->b_headp) break; off = 0; buf[i] = '\n'; } else { buf[i] = lgetc(lp, off); off++; } } buf[i] = '\0'; return (i); } void region_put_data(const char *buf, int len) { int i; for (i = 0; buf[i] != '\0' && i < len; i++) { if (buf[i] == '\n') lnewline(); else linsert(1, buf[i]); } } /* * Mark whole buffer by first traversing to end-of-buffer * and then to beginning-of-buffer. Mark, dot are implicitly * set to eob, bob respectively during traversal. */ int markbuffer(int f, int n) { if (gotoeob(f,n) == FALSE) return (FALSE); if (gotobob(f,n) == FALSE) return (FALSE); return (TRUE); } /* * Pipe text from current region to external command. */ /*ARGSUSED */ int piperegion(int f, int n) { struct region region; int len; char *cmd, cmdbuf[NFILEN], *text; char *argv[] = {"sh", "-c", (char *) NULL, (char *) NULL}; /* C-u M-| is not supported yet */ if (n > 1) return (ABORT); if (curwp->w_markp == NULL) { dobeep(); ewprintf("The mark is not set now, so there is no region"); return (FALSE); } if ((cmd = eread("Shell command on region: ", cmdbuf, sizeof(cmdbuf), EFNEW | EFCR)) == NULL || (cmd[0] == '\0')) return (ABORT); argv[2] = cmd; if (getregion(®ion) != TRUE) return (FALSE); len = region.r_size; if ((text = malloc(len + 1)) == NULL) { dobeep(); ewprintf("Cannot allocate memory."); return (FALSE); } region_get_data(®ion, text, len); return shellcmdoutput(argv, text, len); } /* * Get command from mini-buffer and execute externally. */ /*ARGSUSED */ int shellcommand(int f, int n) { char *cmd, cmdbuf[NFILEN]; char *argv[] = {"sh", "-c", (char *) NULL, (char *) NULL}; if (n > 1) return (ABORT); if ((cmd = eread("Shell command: ", cmdbuf, sizeof(cmdbuf), EFNEW | EFCR)) == NULL || (cmd[0] == '\0')) return (ABORT); argv[2] = cmd; return shellcmdoutput(argv, NULL, 0); } int shellcmdoutput(char* const argv[], char* const text, int len) { struct buffer *bp; char *shellp; int ret; bp = bfind("*Shell Command Output*", TRUE); bp->b_flag |= BFREADONLY; if (bclear(bp) != TRUE) { free(text); return (FALSE); } shellp = getenv("SHELL"); ret = pipeio(shellp, argv, text, len, bp); if (ret == TRUE) { eerase(); if (lforw(bp->b_headp) == bp->b_headp) addline(bp, "(Shell command succeeded with no output)"); } free(text); return (ret); } /* * Create a socketpair, fork and execv path with argv. * STDIN, STDOUT and STDERR of child process are redirected to socket. * Parent writes len chars from text to socket. */ int pipeio(const char* const path, char* const argv[], char* const text, int len, struct buffer *outbp) { int s[2], ret; char *err; pid_t pid; if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, s) == -1) { dobeep(); ewprintf("socketpair error"); return (FALSE); } switch((pid = fork())) { case -1: dobeep(); ewprintf("Can't fork"); return (FALSE); case 0: /* Child process */ close(s[0]); if (dup2(s[1], STDIN_FILENO) == -1) _exit(1); if (dup2(s[1], STDOUT_FILENO) == -1) _exit(1); if (dup2(s[1], STDERR_FILENO) == -1) _exit(1); if (path == NULL) _exit(1); execv(path, argv); err = strerror(errno); write(s[1], err, strlen(err)); _exit(1); default: /* Parent process */ close(s[1]); ret = iomux(s[0], text, len, outbp); waitpid(pid, NULL, 0); /* Collect child to prevent zombies */ return (ret); } return (FALSE); } /* * Multiplex read, write on socket fd passed. Put output in outbp * Poll on the fd for both read and write readiness. */ int iomux(int fd, char* const text, int len, struct buffer *outbp) { struct pollfd pfd[1]; int nfds; char *textcopy; textcopy = text; fcntl(fd, F_SETFL, O_NONBLOCK); pfd[0].fd = fd; /* There is nothing to write if len is zero * but the cmd's output should be read so shutdown * the socket for writing only and don't wait for POLLOUT */ if (len == 0) { shutdown(fd, SHUT_WR); pfd[0].events = POLLIN; } else pfd[0].events = POLLIN | POLLOUT; while ((nfds = poll(pfd, 1, TIMEOUT)) != -1 || (pfd[0].revents & (POLLERR | POLLHUP | POLLNVAL))) { if (pfd[0].revents & POLLOUT && len > 0) pwriteout(fd, &textcopy, &len); else if (pfd[0].revents & POLLIN) if (preadin(fd, outbp) == FALSE) break; if (len == 0 && pfd[0].events & POLLOUT) pfd[0].events = POLLIN; } close(fd); /* In case if last line doesn't have a '\n' add the leftover * characters to buffer. */ if (leftover[0] != '\0') { addline(outbp, leftover); leftover[0] = '\0'; } if (nfds == 0) { dobeep(); ewprintf("poll timed out"); return (FALSE); } else if (nfds == -1) { dobeep(); ewprintf("poll error"); return (FALSE); } return (popbuftop(outbp, WNONE)); } /* * Write some text from region to fd. Once done shutdown the * write end. */ void pwriteout(int fd, char **text, int *len) { int w; /* As per: http://lists.apple.com/archives/macnetworkprog/2002/Dec/msg00091.html */ #ifdef __APPLE__ if (((w = send(fd, *text, *len, SO_NOSIGPIPE)) == -1)) { #else if (((w = send(fd, *text, *len, MSG_NOSIGNAL)) == -1)) { #endif switch(errno) { case EPIPE: *len = -1; break; case EAGAIN: return; } } else *len -= w; *text += w; if (*len <= 0) shutdown(fd, SHUT_WR); } /* * Read some data from socket fd, break on '\n' and add * to buffer. If couldn't break on newline hold leftover * characters and append in next iteration. */ int preadin(int fd, struct buffer *bp) { int len; char buf[BUFSIZ], *p, *q; if ((len = read(fd, buf, BUFSIZ - 1)) <= 0) return (FALSE); buf[len] = '\0'; p = q = buf; if (leftover[0] != '\0' && ((q = strchr(p, '\n')) != NULL)) { *q++ = '\0'; if (strlcat(leftover, p, sizeof(leftover)) >= sizeof(leftover)) { dobeep(); ewprintf("line too long"); return (FALSE); } addline(bp, leftover); leftover[0] = '\0'; p = q; } while ((q = strchr(p, '\n')) != NULL) { *q++ = '\0'; addline(bp, p); p = q; } if (strlcpy(leftover, p, sizeof(leftover)) >= sizeof(leftover)) { dobeep(); ewprintf("line too long"); return (FALSE); } return (TRUE); } mg-20161005/.mg010064400017510001751000000000671276204442100116420ustar00hanboetesauto-indent-mode make-backup-files set-fill-column 72 mg-20161005/search.c010064400017510001751000000440431276204442100126510ustar00hanboetes/* $OpenBSD: search.c,v 1.44 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Search commands. * The functions in this file implement the search commands (both plain and * incremental searches are supported) and the query-replace command. * * The plain old search code is part of the original MicroEMACS "distribution". * The incremental search code and the query-replace code is by Rich Ellison. */ #include #include #include #include #include #include "def.h" #include "macro.h" #define SRCH_BEGIN (0) /* Search sub-codes. */ #define SRCH_FORW (-1) #define SRCH_BACK (-2) #define SRCH_NOPR (-3) #define SRCH_ACCM (-4) #define SRCH_MARK (-5) struct srchcom { int s_code; struct line *s_dotp; int s_doto; int s_dotline; }; static int isearch(int); static void is_cpush(int); static void is_lpush(void); static void is_pop(void); static int is_peek(void); static void is_undo(int *, int *); static int is_find(int); static void is_prompt(int, int, int); static void is_dspl(char *, int); static int eq(int, int, int); static struct srchcom cmds[NSRCH]; static int cip; int srch_lastdir = SRCH_NOPR; /* Last search flags. */ /* * Search forward. Get a search string from the user, and search for it * starting at ".". If found, "." gets moved to just after the matched * characters, and display does all the hard stuff. If not found, it just * prints a message. */ /* ARGSUSED */ int forwsearch(int f, int n) { int s; if ((s = readpattern("Search")) != TRUE) return (s); if (forwsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", pat); return (FALSE); } srch_lastdir = SRCH_FORW; return (TRUE); } /* * Reverse search. Get a search string from the user, and search, starting * at "." and proceeding toward the front of the buffer. If found "." is * left pointing at the first character of the pattern [the last character * that was matched]. */ /* ARGSUSED */ int backsearch(int f, int n) { int s; if ((s = readpattern("Search backward")) != TRUE) return (s); if (backsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", pat); return (FALSE); } srch_lastdir = SRCH_BACK; return (TRUE); } /* * Search again, using the same search string and direction as the last * search command. The direction has been saved in "srch_lastdir", so you * know which way to go. */ /* ARGSUSED */ int searchagain(int f, int n) { if (srch_lastdir == SRCH_FORW) { if (forwsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", pat); return (FALSE); } return (TRUE); } if (srch_lastdir == SRCH_BACK) { if (backsrch() == FALSE) { dobeep(); ewprintf("Search failed: \"%s\"", pat); return (FALSE); } return (TRUE); } dobeep(); ewprintf("No last search"); return (FALSE); } /* * Use incremental searching, initially in the forward direction. * isearch ignores any explicit arguments. */ /* ARGSUSED */ int forwisearch(int f, int n) { if (macrodef || inmacro) /* We can't isearch in macro. Use search instead */ return (forwsearch(f,n)); else return (isearch(SRCH_FORW)); } /* * Use incremental searching, initially in the reverse direction. * isearch ignores any explicit arguments. */ /* ARGSUSED */ int backisearch(int f, int n) { if (macrodef || inmacro) /* We can't isearch in macro. Use search instead */ return (backsearch(f,n)); else return (isearch(SRCH_BACK)); } /* * Incremental Search. * dir is used as the initial direction to search. * ^S switch direction to forward * ^R switch direction to reverse * ^Q quote next character (allows searching for ^N etc.) * exit from Isearch * undoes last character typed. (tricky job to do this correctly). * other ^ exit search, don't set mark * else accumulate into search string */ static int isearch(int dir) { struct line *clp; /* Saved line pointer */ int c; int cbo; /* Saved offset */ int success; int pptr; int firstc; int xcase; int i; char opat[NPAT]; int cdotline; /* Saved line number */ if (macrodef) { dobeep(); ewprintf("Can't isearch in macro"); return (FALSE); } for (cip = 0; cip < NSRCH; cip++) cmds[cip].s_code = SRCH_NOPR; (void)strlcpy(opat, pat, sizeof(opat)); cip = 0; pptr = -1; clp = curwp->w_dotp; cbo = curwp->w_doto; cdotline = curwp->w_dotline; is_lpush(); is_cpush(SRCH_BEGIN); success = TRUE; is_prompt(dir, TRUE, success); for (;;) { update(CMODE); switch (c = getkey(FALSE)) { case CCHR('['): /* * If new characters come in the next 300 msec, * we can assume that they belong to a longer * escaped sequence so we should ungetkey the * ESC to avoid writing out garbage. */ if (ttwait(300) == FALSE) ungetkey(c); srch_lastdir = dir; curwp->w_markp = clp; curwp->w_marko = cbo; curwp->w_markline = cdotline; ewprintf("Mark set"); return (TRUE); case CCHR('G'): if (success != TRUE) { while (is_peek() == SRCH_ACCM) is_undo(&pptr, &dir); success = TRUE; is_prompt(dir, pptr < 0, success); break; } curwp->w_dotp = clp; curwp->w_doto = cbo; curwp->w_dotline = cdotline; curwp->w_rflag |= WFMOVE; srch_lastdir = dir; (void)ctrlg(FFRAND, 0); (void)strlcpy(pat, opat, sizeof(pat)); return (ABORT); case CCHR('S'): if (dir == SRCH_BACK) { dir = SRCH_FORW; is_lpush(); is_cpush(SRCH_FORW); success = TRUE; } if (success == FALSE && dir == SRCH_FORW) { /* wrap the search to beginning */ curwp->w_dotp = bfirstlp(curbp); curwp->w_doto = 0; curwp->w_dotline = 1; if (is_find(dir) != FALSE) { is_cpush(SRCH_MARK); success = TRUE; } ewprintf("Overwrapped I-search: %s", pat); break; } is_lpush(); pptr = strlen(pat); if (forwchar(FFRAND, 1) == FALSE) { dobeep(); success = FALSE; ewprintf("Failed I-search: %s", pat); } else { if (is_find(SRCH_FORW) != FALSE) is_cpush(SRCH_MARK); else { (void)backchar(FFRAND, 1); dobeep(); success = FALSE; ewprintf("Failed I-search: %s", pat); } } is_prompt(dir, pptr < 0, success); break; case CCHR('R'): if (dir == SRCH_FORW) { dir = SRCH_BACK; is_lpush(); is_cpush(SRCH_BACK); success = TRUE; } if (success == FALSE && dir == SRCH_BACK) { /* wrap the search to end */ curwp->w_dotp = blastlp(curbp); curwp->w_doto = llength(curwp->w_dotp); curwp->w_dotline = curwp->w_bufp->b_lines; if (is_find(dir) != FALSE) { is_cpush(SRCH_MARK); success = TRUE; } ewprintf("Overwrapped I-search: %s", pat); break; } is_lpush(); pptr = strlen(pat); if (backchar(FFRAND, 1) == FALSE) { dobeep(); success = FALSE; } else { if (is_find(SRCH_BACK) != FALSE) is_cpush(SRCH_MARK); else { (void)forwchar(FFRAND, 1); dobeep(); success = FALSE; } } is_prompt(dir, pptr < 0, success); break; case CCHR('W'): /* add the rest of the current word to the pattern */ clp = curwp->w_dotp; cbo = curwp->w_doto; firstc = 1; if (pptr == -1) pptr = 0; if (dir == SRCH_BACK) { /* when isearching backwards, cbo is the start of the pattern */ cbo += pptr; } /* if the search is case insensitive, add to pattern using lowercase */ xcase = 0; for (i = 0; pat[i]; i++) if (ISUPPER(CHARMASK(pat[i]))) xcase = 1; while (cbo < llength(clp)) { c = lgetc(clp, cbo++); if ((!firstc && !isalnum(c))) break; if (pptr == NPAT - 1) { dobeep(); break; } firstc = 0; if (!xcase && ISUPPER(c)) c = TOLOWER(c); pat[pptr++] = c; pat[pptr] = '\0'; /* cursor only moves when isearching forwards */ if (dir == SRCH_FORW) { curwp->w_doto = cbo; curwp->w_rflag |= WFMOVE; update(CMODE); } } is_prompt(dir, pptr < 0, success); break; case CCHR('H'): case CCHR('?'): is_undo(&pptr, &dir); if (is_peek() != SRCH_ACCM) success = TRUE; is_prompt(dir, pptr < 0, success); break; case CCHR('\\'): case CCHR('Q'): c = (char)getkey(FALSE); goto addchar; case CCHR('M'): c = CCHR('J'); goto addchar; default: if (ISCTRL(c)) { ungetkey(c); curwp->w_markp = clp; curwp->w_marko = cbo; curwp->w_markline = cdotline; ewprintf("Mark set"); curwp->w_rflag |= WFMOVE; return (TRUE); } /* FALLTHRU */ case CCHR('I'): case CCHR('J'): addchar: if (pptr == -1) pptr = 0; if (pptr == 0) success = TRUE; if (pptr == NPAT - 1) dobeep(); else { pat[pptr++] = c; pat[pptr] = '\0'; } is_lpush(); if (success != FALSE) { if (is_find(dir) != FALSE) is_cpush(c); else { success = FALSE; dobeep(); is_cpush(SRCH_ACCM); } } else is_cpush(SRCH_ACCM); is_prompt(dir, FALSE, success); } } /* NOTREACHED */ } static void is_cpush(int cmd) { if (++cip >= NSRCH) cip = 0; cmds[cip].s_code = cmd; } static void is_lpush(void) { int ctp; ctp = cip + 1; if (ctp >= NSRCH) ctp = 0; cmds[ctp].s_code = SRCH_NOPR; cmds[ctp].s_doto = curwp->w_doto; cmds[ctp].s_dotp = curwp->w_dotp; cmds[ctp].s_dotline = curwp->w_dotline; } static void is_pop(void) { if (cmds[cip].s_code != SRCH_NOPR) { curwp->w_doto = cmds[cip].s_doto; curwp->w_dotp = cmds[cip].s_dotp; curwp->w_dotline = cmds[cip].s_dotline; curwp->w_rflag |= WFMOVE; cmds[cip].s_code = SRCH_NOPR; } if (--cip <= 0) cip = NSRCH - 1; } static int is_peek(void) { return (cmds[cip].s_code); } /* this used to always return TRUE (the return value was checked) */ static void is_undo(int *pptr, int *dir) { int redo = FALSE; switch (cmds[cip].s_code) { case SRCH_BEGIN: case SRCH_NOPR: *pptr = -1; break; case SRCH_MARK: break; case SRCH_FORW: *dir = SRCH_BACK; redo = TRUE; break; case SRCH_BACK: *dir = SRCH_FORW; redo = TRUE; break; case SRCH_ACCM: default: *pptr -= 1; if (*pptr < 0) *pptr = 0; pat[*pptr] = '\0'; break; } is_pop(); if (redo) is_undo(pptr, dir); } static int is_find(int dir) { int plen, odoto, odotline; struct line *odotp; odoto = curwp->w_doto; odotp = curwp->w_dotp; odotline = curwp->w_dotline; plen = strlen(pat); if (plen != 0) { if (dir == SRCH_FORW) { (void)backchar(FFARG | FFRAND, plen); if (forwsrch() == FALSE) { curwp->w_doto = odoto; curwp->w_dotp = odotp; curwp->w_dotline = odotline; return (FALSE); } return (TRUE); } if (dir == SRCH_BACK) { (void)forwchar(FFARG | FFRAND, plen); if (backsrch() == FALSE) { curwp->w_doto = odoto; curwp->w_dotp = odotp; curwp->w_dotline = odotline; return (FALSE); } return (TRUE); } dobeep(); ewprintf("bad call to is_find"); return (FALSE); } return (FALSE); } /* * If called with "dir" not one of SRCH_FORW or SRCH_BACK, this routine used * to print an error message. It also used to return TRUE or FALSE, depending * on if it liked the "dir". However, none of the callers looked at the * status, so I just made the checking vanish. */ static void is_prompt(int dir, int flag, int success) { if (dir == SRCH_FORW) { if (success != FALSE) is_dspl("I-search", flag); else is_dspl("Failing I-search", flag); } else if (dir == SRCH_BACK) { if (success != FALSE) is_dspl("I-search backward", flag); else is_dspl("Failing I-search backward", flag); } else ewprintf("Broken call to is_prompt"); } /* * Prompt writing routine for the incremental search. The "prompt" is just * a string. The "flag" determines whether pat should be printed. */ static void is_dspl(char *prompt, int flag) { if (flag != FALSE) ewprintf("%s: ", prompt); else ewprintf("%s: %s", prompt, pat); } /* * Query Replace. * Replace strings selectively. Does a search and replace operation. */ /* ARGSUSED */ int queryrepl(int f, int n) { int s; int rcnt = 0; /* replacements made so far */ int plen; /* length of found string */ char news[NPAT], *rep; /* replacement string */ if (macrodef) { dobeep(); ewprintf("Can't query replace in macro"); return (FALSE); } if ((s = readpattern("Query replace")) != TRUE) return (s); if ((rep = eread("Query replace %s with: ", news, NPAT, EFNUL | EFNEW | EFCR, pat)) == NULL) return (ABORT); else if (rep[0] == '\0') news[0] = '\0'; ewprintf("Query replacing %s with %s:", pat, news); plen = strlen(pat); /* * Search forward repeatedly, checking each time whether to insert * or not. The "!" case makes the check always true, so it gets put * into a tighter loop for efficiency. */ while (forwsrch() == TRUE) { retry: update(CMODE); switch (getkey(FALSE)) { case 'y': case ' ': if (lreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; break; case '.': if (lreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; goto stopsearch; /* ^G, CR or ESC */ case CCHR('G'): (void)ctrlg(FFRAND, 0); goto stopsearch; case CCHR('['): case CCHR('M'): goto stopsearch; case '!': do { if (lreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; } while (forwsrch() == TRUE); goto stopsearch; case 'n': case CCHR('H'): /* To not replace */ case CCHR('?'): break; default: ewprintf("y/n or /: replace/don't, [.] repl-end, [!] repl-rest, / quit"); goto retry; } } stopsearch: curwp->w_rflag |= WFFULL; update(CMODE); if (rcnt == 1) ewprintf("Replaced 1 occurrence"); else ewprintf("Replaced %d occurrences", rcnt); return (TRUE); } /* * Replace string globally without individual prompting. */ /* ARGSUSED */ int replstr(int f, int n) { char news[NPAT]; int s, plen, rcnt = 0; char *r; if ((s = readpattern("Replace string")) != TRUE) return s; r = eread("Replace string %s with: ", news, NPAT, EFNUL | EFNEW | EFCR, pat); if (r == NULL) return (ABORT); plen = strlen(pat); while (forwsrch() == TRUE) { update(CMODE); if (lreplace((RSIZE)plen, news) == FALSE) return (FALSE); rcnt++; } curwp->w_rflag |= WFFULL; update(CMODE); if (rcnt == 1) ewprintf("Replaced 1 occurrence"); else ewprintf("Replaced %d occurrences", rcnt); return (TRUE); } /* * This routine does the real work of a forward search. The pattern is sitting * in the external variable "pat". If found, dot is updated, the window system * is notified of the change, and TRUE is returned. If the string isn't found, * FALSE is returned. */ int forwsrch(void) { struct line *clp, *tlp; int cbo, tbo, c, i, xcase = 0; char *pp; int nline; clp = curwp->w_dotp; cbo = curwp->w_doto; nline = curwp->w_dotline; for (i = 0; pat[i]; i++) if (ISUPPER(CHARMASK(pat[i]))) xcase = 1; for (;;) { if (cbo == llength(clp)) { if ((clp = lforw(clp)) == curbp->b_headp) break; nline++; cbo = 0; c = CCHR('J'); } else c = lgetc(clp, cbo++); if (eq(c, pat[0], xcase) != FALSE) { tlp = clp; tbo = cbo; pp = &pat[1]; while (*pp != 0) { if (tbo == llength(tlp)) { tlp = lforw(tlp); if (tlp == curbp->b_headp) goto fail; tbo = 0; c = CCHR('J'); if (eq(c, *pp++, xcase) == FALSE) goto fail; nline++; } else { c = lgetc(tlp, tbo++); if (eq(c, *pp++, xcase) == FALSE) goto fail; } } curwp->w_dotp = tlp; curwp->w_doto = tbo; curwp->w_dotline = nline; curwp->w_rflag |= WFMOVE; return (TRUE); } fail: ; } return (FALSE); } /* * This routine does the real work of a backward search. The pattern is * sitting in the external variable "pat". If found, dot is updated, the * window system is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ int backsrch(void) { struct line *clp, *tlp; int cbo, tbo, c, i, xcase = 0; char *epp, *pp; int nline, pline; for (epp = &pat[0]; epp[1] != 0; ++epp); clp = curwp->w_dotp; cbo = curwp->w_doto; nline = curwp->w_dotline; for (i = 0; pat[i]; i++) if (ISUPPER(CHARMASK(pat[i]))) xcase = 1; for (;;) { if (cbo == 0) { clp = lback(clp); if (clp == curbp->b_headp) return (FALSE); nline--; cbo = llength(clp) + 1; } if (--cbo == llength(clp)) c = CCHR('J'); else c = lgetc(clp, cbo); if (eq(c, *epp, xcase) != FALSE) { tlp = clp; tbo = cbo; pp = epp; pline = nline; while (pp != &pat[0]) { if (tbo == 0) { tlp = lback(tlp); if (tlp == curbp->b_headp) goto fail; nline--; tbo = llength(tlp) + 1; } if (--tbo == llength(tlp)) c = CCHR('J'); else c = lgetc(tlp, tbo); if (eq(c, *--pp, xcase) == FALSE) { nline = pline; goto fail; } } curwp->w_dotp = tlp; curwp->w_doto = tbo; curwp->w_dotline = nline; curwp->w_rflag |= WFMOVE; return (TRUE); } fail: ; } /* NOTREACHED */ } /* * Compare two characters. The "bc" comes from the buffer. It has its case * folded out. The "pc" is from the pattern. */ static int eq(int bc, int pc, int xcase) { bc = CHARMASK(bc); pc = CHARMASK(pc); if (bc == pc) return (TRUE); if (xcase) return (FALSE); if (ISUPPER(bc)) return (TOLOWER(bc) == pc); if (ISUPPER(pc)) return (bc == TOLOWER(pc)); return (FALSE); } /* * Read a pattern. Stash it in the external variable "pat". The "pat" is not * updated if the user types in an empty line. If the user typed an empty * line, and there is no old pattern, it is an error. Display the old pattern, * in the style of Jeff Lomicka. There is some do-it-yourself control * expansion. */ int readpattern(char *prompt) { char tpat[NPAT], *rep; int retval; if (pat[0] == '\0') rep = eread("%s: ", tpat, NPAT, EFNEW | EFCR, prompt); else rep = eread("%s: (default %s) ", tpat, NPAT, EFNUL | EFNEW | EFCR, prompt, pat); /* specified */ if (rep == NULL) { retval = ABORT; } else if (rep[0] != '\0') { (void)strlcpy(pat, tpat, sizeof(pat)); retval = TRUE; } else if (pat[0] != '\0') { retval = TRUE; } else retval = FALSE; return (retval); } mg-20161005/spawn.c010064400017510001751000000017531276204442100125350ustar00hanboetes/* $OpenBSD: spawn.c,v 1.12 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Spawn. Actually just suspends Mg. * Assumes POSIX job control. */ #include #include #include #include #include #include "def.h" /* * This causes mg to send itself a stop signal. It assumes the parent * shell supports POSIX job control. If the terminal supports an alternate * screen, we will switch to it. */ /* ARGSUSED */ int spawncli(int f, int n) { sigset_t oset; /* Very similar to what vttidy() does. */ ttcolor(CTEXT); ttnowindow(); ttmove(nrow - 1, 0); if (epresf != FALSE) { tteeol(); epresf = FALSE; } if (ttcooked() == FALSE) return (FALSE); /* Exit application mode and tidy. */ tttidy(); ttflush(); (void)sigprocmask(SIG_SETMASK, NULL, &oset); (void)kill(0, SIGTSTP); (void)sigprocmask(SIG_SETMASK, &oset, NULL); ttreinit(); /* Force repaint. */ sgarbf = TRUE; return (ttraw()); } mg-20161005/tags.c010064400017510001751000000271571276204466300123610ustar00hanboetes/* $OpenBSD: tags.c,v 1.14 2016/09/01 10:01:53 sunil Exp $ */ /* * This file is in the public domain. * * Author: Sunil Nimmagadda */ #include #include #include #include #include #include #include #include #include #include #include #include #if defined(LIBBSD_OVERLAY) || defined(__FreeBSD__) || defined(__GLIBC__) # include #else #include #endif #include "def.h" struct ctag; static int addctag(char *); static int atbow(void); void closetags(void); static int ctagcmp(struct ctag *, struct ctag *); static int loadbuffer(char *); static int loadtags(const char *); static int pushtag(char *); static int searchpat(char *); static struct ctag *searchtag(char *); static char *strip(char *, size_t); static void unloadtags(void); #define DEFAULTFN "tags" char *tagsfn = NULL; int loaded = FALSE; /* ctags(1) entries are parsed and maintained in a tree. */ struct ctag { RB_ENTRY(ctag) entry; char *tag; char *fname; char *pat; }; RB_HEAD(tagtree, ctag) tags = RB_INITIALIZER(&tags); RB_GENERATE(tagtree, ctag, entry, ctagcmp); struct tagpos { SLIST_ENTRY(tagpos) entry; int doto; int dotline; char *bname; }; SLIST_HEAD(tagstack, tagpos) shead = SLIST_HEAD_INITIALIZER(shead); int ctagcmp(struct ctag *s, struct ctag *t) { return strcmp(s->tag, t->tag); } /* * Record the filename that contain tags to be used while loading them * on first use. If a filename is already recorded, ask user to retain * already loaded tags (if any) and unload them if user chooses not to. */ /* ARGSUSED */ int tagsvisit(int f, int n) { char fname[NFILEN], *bufp, *temp; struct stat sb; if (getbufcwd(fname, sizeof(fname)) == FALSE) fname[0] = '\0'; if (strlcat(fname, DEFAULTFN, sizeof(fname)) >= sizeof(fname)) { dobeep(); ewprintf("Filename too long"); return (FALSE); } bufp = eread("visit tags table (default %s): ", fname, NFILEN, EFFILE | EFCR | EFNEW | EFDEF, DEFAULTFN); if (bufp == NULL) return (ABORT); if (stat(bufp, &sb) == -1) { dobeep(); ewprintf("stat: %s", strerror(errno)); return (FALSE); } else if (S_ISREG(sb.st_mode) == 0) { dobeep(); ewprintf("Not a regular file"); return (FALSE); } else if (access(bufp, R_OK) == -1) { dobeep(); ewprintf("Cannot access file %s", bufp); return (FALSE); } if (tagsfn == NULL) { if (bufp[0] == '\0') { if ((tagsfn = strdup(fname)) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } } else { /* bufp points to local variable, so duplicate. */ if ((tagsfn = strdup(bufp)) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } } } else { if ((temp = strdup(bufp)) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } free(tagsfn); tagsfn = temp; if (eyorn("Keep current list of tags table also") == FALSE) { ewprintf("Starting a new list of tags table"); unloadtags(); } loaded = FALSE; } return (TRUE); } /* * Ask user for a tag while treating word at dot as default. Visit tags * file if not yet done, load tags and jump to definition of the tag. */ int findtag(int f, int n) { char utok[MAX_TOKEN], dtok[MAX_TOKEN]; char *tok, *bufp; int ret; if (curtoken(f, n, dtok) == FALSE) { dtok[0] = '\0'; bufp = eread("Find tag:", utok, MAX_TOKEN, EFNUL | EFNEW); } else bufp = eread("Find tag (default %s):", utok, MAX_TOKEN, EFNUL | EFNEW, dtok); if (bufp == NULL) return (ABORT); else if (bufp[0] == '\0') tok = dtok; else tok = utok; if (tok[0] == '\0') { dobeep(); ewprintf("There is no default tag"); return (FALSE); } if (tagsfn == NULL) if ((ret = tagsvisit(f, n)) != TRUE) return (ret); if (!loaded) { if (loadtags(tagsfn) == FALSE) { free(tagsfn); tagsfn = NULL; return (FALSE); } loaded = TRUE; } return pushtag(tok); } /* * Free tags tree. */ void unloadtags(void) { struct ctag *var, *nxt; for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) { nxt = RB_NEXT(tagtree, &tags, var); RB_REMOVE(tagtree, &tags, var); /* line parsed with fparseln needs to be freed */ free(var->tag); free(var); } } /* * Lookup tag passed in tree and if found, push current location and * buffername onto stack, load the file with tag definition into a new * buffer and position dot at the pattern. */ /*ARGSUSED */ int pushtag(char *tok) { struct ctag *res; struct tagpos *s; char bname[NFILEN]; int doto, dotline; if ((res = searchtag(tok)) == NULL) return (FALSE); doto = curwp->w_doto; dotline = curwp->w_dotline; /* record absolute filenames. Fixes issues when mg's cwd is not the * same as buffer's directory. */ if (strlcpy(bname, curbp->b_cwd, sizeof(bname)) >= sizeof(bname)) { dobeep(); ewprintf("filename too long"); return (FALSE); } if (strlcat(bname, curbp->b_bname, sizeof(bname)) >= sizeof(bname)) { dobeep(); ewprintf("filename too long"); return (FALSE); } if (loadbuffer(res->fname) == FALSE) return (FALSE); if (searchpat(res->pat) == TRUE) { if ((s = malloc(sizeof(struct tagpos))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } if ((s->bname = strdup(bname)) == NULL) { dobeep(); ewprintf("Out of memory"); free(s); return (FALSE); } s->doto = doto; s->dotline = dotline; SLIST_INSERT_HEAD(&shead, s, entry); return (TRUE); } else { dobeep(); ewprintf("%s: pattern not found", res->tag); return (FALSE); } /* NOTREACHED */ return (FALSE); } /* * If tag stack is not empty pop stack and jump to recorded buffer, dot. */ /* ARGSUSED */ int poptag(int f, int n) { struct line *dotp; struct tagpos *s; if (SLIST_EMPTY(&shead)) { dobeep(); ewprintf("No previous location for find-tag invocation"); return (FALSE); } s = SLIST_FIRST(&shead); SLIST_REMOVE_HEAD(&shead, entry); if (loadbuffer(s->bname) == FALSE) return (FALSE); curwp->w_dotline = s->dotline; curwp->w_doto = s->doto; /* storing of dotp in tagpos wouldn't work out in cases when * that buffer is killed by user(dangling pointer). Explicitly * traverse till dotline for correct handling. */ dotp = curwp->w_bufp->b_headp; while (s->dotline--) dotp = dotp->l_fp; curwp->w_dotp = dotp; free(s->bname); free(s); return (TRUE); } /* * Parse the tags file and construct the tags tree. Remove escape * characters while parsing the file. */ int loadtags(const char *fn) { char *l; FILE *fd; if ((fd = fopen(fn, "r")) == NULL) { dobeep(); ewprintf("Unable to open tags file: %s", fn); return (FALSE); } while ((l = fparseln(fd, NULL, NULL, "\\\\\0", FPARSELN_UNESCCONT | FPARSELN_UNESCREST)) != NULL) { if (addctag(l) == FALSE) { fclose(fd); return (FALSE); } } fclose(fd); return (TRUE); } /* * Cleanup and destroy tree and stack. */ void closetags(void) { struct tagpos *s; while (!SLIST_EMPTY(&shead)) { s = SLIST_FIRST(&shead); SLIST_REMOVE_HEAD(&shead, entry); free(s->bname); free(s); } unloadtags(); free(tagsfn); } /* * Strip away any special characters in pattern. * The pattern in ctags isn't a true regular expression. Its of the form * /^xxx$/ or ?^xxx$? and in some cases the "$" would be missing. Strip * the leading and trailing special characters so the pattern matching * would be a simple string compare. Escape character is taken care by * fparseln. */ char * strip(char *s, size_t len) { /* first strip trailing special chars */ s[len - 1] = '\0'; if (s[len - 2] == '$') s[len - 2] = '\0'; /* then strip leading special chars */ s++; if (*s == '^') s++; return s; } /* * tags line is of the format "\t\t". Split them * by replacing '\t' with '\0'. This wouldn't alter the size of malloc'ed * l, and can be freed during cleanup. */ int addctag(char *l) { struct ctag *t; if ((t = malloc(sizeof(struct ctag))) == NULL) { dobeep(); ewprintf("Out of memory"); return (FALSE); } t->tag = l; if ((l = strchr(l, '\t')) == NULL) goto cleanup; *l++ = '\0'; t->fname = l; if ((l = strchr(l, '\t')) == NULL) goto cleanup; *l++ = '\0'; if (*l == '\0') goto cleanup; t->pat = strip(l, strlen(l)); RB_INSERT(tagtree, &tags, t); return (TRUE); cleanup: free(t); free(l); return (FALSE); } /* * Search through each line of buffer for pattern. */ int searchpat(char *pat) { struct line *lp; int dotline; size_t plen; plen = strlen(pat); dotline = 1; lp = lforw(curbp->b_headp); while (lp != curbp->b_headp) { if (ltext(lp) != NULL && plen <= llength(lp) && (strncmp(pat, ltext(lp), plen) == 0)) { curwp->w_doto = 0; curwp->w_dotp = lp; curwp->w_dotline = dotline; return (TRUE); } else { lp = lforw(lp); dotline++; } } return (FALSE); } /* * Return TRUE if dot is at beginning of a word or at beginning * of line, else FALSE. */ int atbow(void) { if (curwp->w_doto == 0) return (TRUE); if (ISWORD(curwp->w_dotp->l_text[curwp->w_doto]) && !ISWORD(curwp->w_dotp->l_text[curwp->w_doto - 1])) return (TRUE); return (FALSE); } /* * Extract the word at dot without changing dot position. */ int curtoken(int f, int n, char *token) { struct line *odotp; int odoto, tdoto, odotline, size, r; char c; /* Underscore character is to be treated as "inword" while * processing tokens unlike mg's default word traversal. Save * and restore it's cinfo value so that tag matching works for * identifier with underscore. */ c = cinfo['_']; cinfo['_'] = _MG_W; odotp = curwp->w_dotp; odoto = curwp->w_doto; odotline = curwp->w_dotline; /* Move backword unless we are at the beginning of a word or at * beginning of line. */ if (!atbow()) if ((r = backword(f, n)) == FALSE) goto cleanup; tdoto = curwp->w_doto; if ((r = forwword(f, n)) == FALSE) goto cleanup; /* strip away leading whitespace if any like emacs. */ while (ltext(curwp->w_dotp) && isspace(lgetc(curwp->w_dotp, tdoto))) tdoto++; size = curwp->w_doto - tdoto; if (size <= 0 || size >= MAX_TOKEN || ltext(curwp->w_dotp) == NULL) { r = FALSE; goto cleanup; } strncpy(token, ltext(curwp->w_dotp) + tdoto, size); token[size] = '\0'; r = TRUE; cleanup: cinfo['_'] = c; curwp->w_dotp = odotp; curwp->w_doto = odoto; curwp->w_dotline = odotline; return (r); } /* * Search tagstree for a given token. */ struct ctag * searchtag(char *tok) { struct ctag t, *res; t.tag = tok; if ((res = RB_FIND(tagtree, &tags, &t)) == NULL) { dobeep(); ewprintf("No tag containing %s", tok); return (NULL); } return res; } /* * This is equivalent to filevisit from file.c. * Look around to see if we can find the file in another buffer; if we * can't find it, create a new buffer, read in the text, and switch to * the new buffer. *scratch*, *grep*, *compile* needs to be handled * differently from other buffers which have "filenames". */ int loadbuffer(char *bname) { struct buffer *bufp; char *adjf; /* check for special buffers which begin with '*' */ if (bname[0] == '*') { if ((bufp = bfind(bname, FALSE)) != NULL) { curbp = bufp; return (showbuffer(bufp, curwp, WFFULL)); } else { return (FALSE); } } else { if ((adjf = adjustname(bname, TRUE)) == NULL) return (FALSE); if ((bufp = findbuffer(adjf)) == NULL) return (FALSE); } curbp = bufp; if (showbuffer(bufp, curwp, WFFULL) != TRUE) return (FALSE); if (bufp->b_fname[0] == '\0') { if (readin(adjf) != TRUE) { killbuffer(bufp); return (FALSE); } } return (TRUE); } mg-20161005/tty.c010064400017510001751000000242271276204442100122260ustar00hanboetes/* $OpenBSD: tty.c,v 1.36 2015/11/18 18:44:50 jasper Exp $ */ /* This file is in the public domain. */ /* * Terminfo display driver * * Terminfo is a terminal information database and routines to describe * terminals on most modern UNIX systems. Many other systems have adopted * this as a reasonable way to allow for widely varying and ever changing * varieties of terminal types. This should be used where practical. */ /* * Known problems: If you have a terminal with no clear to end of screen and * memory of lines below the ones visible on the screen, display will be * wrong in some cases. I doubt that any such terminal was ever made, but I * thought everyone with delete line would have clear to end of screen too... * * Code for terminals without clear to end of screen and/or clear to end of line * has not been extensively tested. * * Cost calculations are very rough. Costs of insert/delete line may be far * from the truth. This is accentuated by display.c not knowing about * multi-line insert/delete. * * Using scrolling region vs insert/delete line should probably be based on cost * rather than the assumption that scrolling region operations look better. */ #include #include #include #include #include #include #include #include "def.h" static int charcost(const char *); static int cci; static int insdel; /* Do we have both insert & delete line? */ static const char *scroll_fwd; /* How to scroll forward. */ static void winchhandler(int); /* ARGSUSED */ static void winchhandler(int sig) { winch_flag = 1; } /* * Initialize the terminal when the editor * gets started up. */ void ttinit(void) { int errret; if (setupterm(NULL, 1, &errret)) panic("Terminal setup failed"); signal(SIGWINCH, winchhandler); signal(SIGCONT, winchhandler); siginterrupt(SIGWINCH, 1); scroll_fwd = scroll_forward; if (scroll_fwd == NULL || *scroll_fwd == '\0') { /* this is what GNU Emacs does */ scroll_fwd = parm_down_cursor; if (scroll_fwd == NULL || *scroll_fwd == '\0') scroll_fwd = "\n"; } if (cursor_address == NULL || cursor_up == NULL) panic("This terminal is too stupid to run mg"); /* set nrow & ncol */ ttresize(); if (!clr_eol) tceeol = ncol; else tceeol = charcost(clr_eol); /* Estimate cost of inserting a line */ if (change_scroll_region && scroll_reverse) tcinsl = charcost(change_scroll_region) * 2 + charcost(scroll_reverse); else if (parm_insert_line) tcinsl = charcost(parm_insert_line); else if (insert_line) tcinsl = charcost(insert_line); else /* make this cost high enough */ tcinsl = nrow * ncol; /* Estimate cost of deleting a line */ if (change_scroll_region) tcdell = charcost(change_scroll_region) * 2 + charcost(scroll_fwd); else if (parm_delete_line) tcdell = charcost(parm_delete_line); else if (delete_line) tcdell = charcost(delete_line); else /* make this cost high enough */ tcdell = nrow * ncol; /* Flag to indicate that we can both insert and delete lines */ insdel = (insert_line || parm_insert_line) && (delete_line || parm_delete_line); if (enter_ca_mode) /* enter application mode */ putpad(enter_ca_mode, 1); ttresize(); } /* * Re-initialize the terminal when the editor is resumed. * The keypad_xmit doesn't really belong here but... */ void ttreinit(void) { /* check if file was modified while we were gone */ if (fchecktime(curbp) != TRUE) { curbp->b_flag |= BFDIRTY; } if (enter_ca_mode) /* enter application mode */ putpad(enter_ca_mode, 1); if (keypad_xmit) /* turn on keypad */ putpad(keypad_xmit, 1); ttresize(); } /* * Clean up the terminal, in anticipation of a return to the command * interpreter. This is a no-op on the ANSI display. On the SCALD display, * it sets the window back to half screen scrolling. Perhaps it should * query the display for the increment, and put it back to what it was. */ void tttidy(void) { ttykeymaptidy(); /* set the term back to normal mode */ if (exit_ca_mode) putpad(exit_ca_mode, 1); } /* * Move the cursor to the specified origin 0 row and column position. Try to * optimize out extra moves; redisplay may have left the cursor in the right * location last time! */ void ttmove(int row, int col) { if (ttrow != row || ttcol != col) { putpad(tgoto(cursor_address, col, row), 1); ttrow = row; ttcol = col; } } /* * Erase to end of line. */ void tteeol(void) { int i; if (clr_eol) putpad(clr_eol, 1); else { i = ncol - ttcol; while (i--) ttputc(' '); ttrow = ttcol = HUGE; } } /* * Erase to end of page. */ void tteeop(void) { int line; if (clr_eos) putpad(clr_eos, nrow - ttrow); else { putpad(clr_eol, 1); if (insdel) ttdell(ttrow + 1, lines, lines - ttrow - 1); else { /* do it by hand */ for (line = ttrow + 1; line <= lines; ++line) { ttmove(line, 0); tteeol(); } } ttrow = ttcol = HUGE; } } /* * Make a noise. */ void ttbeep(void) { putpad(bell, 1); ttflush(); } /* * Insert nchunk blank line(s) onto the screen, scrolling the last line on * the screen off the bottom. Use the scrolling region if possible for a * smoother display. If there is no scrolling region, use a set of insert * and delete line sequences. */ void ttinsl(int row, int bot, int nchunk) { int i, nl; /* One line special cases */ if (row == bot) { ttmove(row, 0); tteeol(); return; } /* Use scroll region and back index */ if (change_scroll_region && scroll_reverse) { nl = bot - row; ttwindow(row, bot); ttmove(row, 0); while (nchunk--) putpad(scroll_reverse, nl); ttnowindow(); return; /* else use insert/delete line */ } else if (insdel) { ttmove(1 + bot - nchunk, 0); nl = nrow - ttrow; if (parm_delete_line) putpad(tgoto(parm_delete_line, 0, nchunk), nl); else /* For all lines in the chunk */ for (i = 0; i < nchunk; i++) putpad(delete_line, nl); ttmove(row, 0); /* ttmove() changes ttrow */ nl = nrow - ttrow; if (parm_insert_line) putpad(tgoto(parm_insert_line, 0, nchunk), nl); else /* For all lines in the chunk */ for (i = 0; i < nchunk; i++) putpad(insert_line, nl); ttrow = HUGE; ttcol = HUGE; } else panic("ttinsl: Can't insert/delete line"); } /* * Delete nchunk line(s) from "row", replacing the bottom line on the * screen with a blank line. Unless we're using the scrolling region, * this is done with crafty sequences of insert and delete lines. The * presence of the echo area makes a boundary condition go away. */ void ttdell(int row, int bot, int nchunk) { int i, nl; /* One line special cases */ if (row == bot) { ttmove(row, 0); tteeol(); return; } /* scrolling region */ if (change_scroll_region) { nl = bot - row; ttwindow(row, bot); ttmove(bot, 0); while (nchunk--) putpad(scroll_fwd, nl); ttnowindow(); /* else use insert/delete line */ } else if (insdel) { ttmove(row, 0); nl = nrow - ttrow; if (parm_delete_line) putpad(tgoto(parm_delete_line, 0, nchunk), nl); else /* For all lines in the chunk */ for (i = 0; i < nchunk; i++) putpad(delete_line, nl); ttmove(1 + bot - nchunk, 0); /* ttmove() changes ttrow */ nl = nrow - ttrow; if (parm_insert_line) putpad(tgoto(parm_insert_line, 0, nchunk), nl); else /* For all lines in the chunk */ for (i = 0; i < nchunk; i++) putpad(insert_line, nl); ttrow = HUGE; ttcol = HUGE; } else panic("ttdell: Can't insert/delete line"); } /* * This routine sets the scrolling window on the display to go from line * "top" to line "bot" (origin 0, inclusive). The caller checks for the * pathological 1-line scroll window which doesn't work right and avoids * it. The "ttrow" and "ttcol" variables are set to a crazy value to * ensure that the next call to "ttmove" does not turn into a no-op (the * window adjustment moves the cursor). */ void ttwindow(int top, int bot) { if (change_scroll_region && (tttop != top || ttbot != bot)) { putpad(tgoto(change_scroll_region, bot, top), nrow - ttrow); ttrow = HUGE; /* Unknown. */ ttcol = HUGE; tttop = top; /* Remember region. */ ttbot = bot; } } /* * Switch to full screen scroll. This is used by "spawn.c" just before it * suspends the editor and by "display.c" when it is getting ready to * exit. This function does a full screen scroll by telling the terminal * to set a scrolling region that is lines or nrow rows high, whichever is * larger. This behavior seems to work right on systems where you can set * your terminal size. */ void ttnowindow(void) { if (change_scroll_region) { putpad(tgoto(change_scroll_region, (nrow > lines ? nrow : lines) - 1, 0), nrow - ttrow); ttrow = HUGE; /* Unknown. */ ttcol = HUGE; tttop = HUGE; /* No scroll region. */ ttbot = HUGE; } } /* * Set the current writing color to the specified color. Watch for color * changes that are not going to do anything (the color is already right) * and don't send anything to the display. The rainbow version does this * in putline.s on a line by line basis, so don't bother sending out the * color shift. */ void ttcolor(int color) { if (color != tthue) { if (color == CTEXT) /* normal video */ putpad(exit_standout_mode, 1); else if (color == CMODE) /* reverse video */ putpad(enter_standout_mode, 1); /* save the color */ tthue = color; } } /* * This routine is called by the "refresh the screen" command to try * to resize the display. Look in "window.c" to see how * the caller deals with a change. * * We use `newrow' and `newcol' so vtresize() know the difference between the * new and old settings. */ void ttresize(void) { int newrow = 0, newcol = 0; struct winsize winsize; if (ioctl(0, TIOCGWINSZ, &winsize) == 0) { newrow = winsize.ws_row; newcol = winsize.ws_col; } if ((newrow <= 0 || newcol <= 0) && ((newrow = lines) <= 0 || (newcol = columns) <= 0)) { newrow = 24; newcol = 80; } if (vtresize(1, newrow, newcol) != TRUE) panic("vtresize failed"); } /* * fake char output for charcost() */ /* ARGSUSED */ static int fakec(int c) { cci++; return (0); } /* calculate the cost of doing string s */ static int charcost(const char *s) { cci = 0; tputs(s, nrow, fakec); return (cci); } mg-20161005/ttyio.c010064400017510001751000000111021276204442100125420ustar00hanboetes/* $OpenBSD: ttyio.c,v 1.37 2015/03/23 12:31:19 bcallah Exp $ */ /* This file is in the public domain. */ /* * POSIX terminal I/O. * * The functions in this file negotiate with the operating system for * keyboard characters, and write characters to the display in a barely * buffered fashion. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef TCSASOFT #define TCSASOFT 0 #endif #include #include "def.h" #define NOBUF 512 /* Output buffer size. */ int ttstarted; char obuf[NOBUF]; /* Output buffer. */ size_t nobuf; /* Buffer count. */ struct termios oldtty; /* POSIX tty settings. */ struct termios newtty; int nrow; /* Terminal size, rows. */ int ncol; /* Terminal size, columns. */ /* * This function gets called once, to set up the terminal. * On systems w/o TCSASOFT we turn off off flow control, * which isn't really the right thing to do. */ void ttopen(void) { if (!isatty(STDIN_FILENO) || !isatty(STDOUT_FILENO)) panic("standard input and output must be a terminal"); if (ttraw() == FALSE) panic("aborting due to terminal initialize failure"); } /* * This function sets the terminal to RAW mode, as defined for the current * shell. This is called both by ttopen() above and by spawncli() to * get the current terminal settings and then change them to what * mg expects. Thus, tty changes done while spawncli() is in effect * will be reflected in mg. */ int ttraw(void) { if (tcgetattr(0, &oldtty) < 0) { dobeep(); ewprintf("ttopen can't get terminal attributes"); return (FALSE); } (void)memcpy(&newtty, &oldtty, sizeof(newtty)); /* Set terminal to 'raw' mode and ignore a 'break' */ newtty.c_cc[VMIN] = 1; newtty.c_cc[VTIME] = 0; newtty.c_iflag |= IGNBRK; newtty.c_iflag &= ~(BRKINT | PARMRK | INLCR | IGNCR | ICRNL | IXON); newtty.c_oflag &= ~OPOST; newtty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); if (tcsetattr(0, TCSASOFT | TCSADRAIN, &newtty) < 0) { dobeep(); ewprintf("ttopen can't tcsetattr"); return (FALSE); } ttstarted = 1; return (TRUE); } /* * This function gets called just before we go back home to the shell. * Put all of the terminal parameters back. * Under UN*X this just calls ttcooked(), but the ttclose() hook is in * because vttidy() in display.c expects it for portability reasons. */ void ttclose(void) { if (ttstarted) { if (ttcooked() == FALSE) panic(""); /* ttcooked() already printf'd */ ttstarted = 0; } } /* * This function restores all terminal settings to their default values, * in anticipation of exiting or suspending the editor. */ int ttcooked(void) { ttflush(); if (tcsetattr(0, TCSASOFT | TCSADRAIN, &oldtty) < 0) { dobeep(); ewprintf("ttclose can't tcsetattr"); return (FALSE); } return (TRUE); } /* * Write character to the display. Characters are buffered up, * to make things a little bit more efficient. */ int ttputc(int c) { if (nobuf >= NOBUF) ttflush(); obuf[nobuf++] = c; return (c); } /* * Flush output. */ void ttflush(void) { ssize_t written; char *buf = obuf; if (nobuf == 0) return; while ((written = write(fileno(stdout), buf, nobuf)) != nobuf) { if (written == -1) { if (errno == EINTR) continue; panic("ttflush write failed"); } buf += written; nobuf -= written; } nobuf = 0; } /* * Read character from terminal. All 8 bits are returned, so that you * can use a multi-national terminal. */ int ttgetc(void) { char c; ssize_t ret; do { ret = read(STDIN_FILENO, &c, 1); if (ret == -1 && errno == EINTR) { if (winch_flag) { redraw(0, 0); winch_flag = 0; } } else if (ret == -1 && errno == EIO) panic("lost stdin"); else if (ret == 1) break; } while (1); return ((int) c) & 0xFF; } /* * Returns TRUE if there are characters waiting to be read. */ int charswaiting(void) { int x; return ((ioctl(0, FIONREAD, &x) < 0) ? 0 : x); } /* * panic - just exit, as quickly as we can. */ void panic(char *s) { static int panicking = 0; if (panicking) return; else panicking = 1; ttclose(); (void) fputs("panic: ", stderr); (void) fputs(s, stderr); (void) fputc('\n', stderr); exit(1); } /* * This function returns FALSE if any characters have showed up on the * tty before 'msec' milliseconds. */ int ttwait(int msec) { struct pollfd pfd[1]; pfd[0].fd = 0; pfd[0].events = POLLIN; if ((poll(pfd, 1, msec)) == 0) return (TRUE); return (FALSE); } mg-20161005/ttykbd.c010064400017510001751000000035111276204442100127000ustar00hanboetes/* $OpenBSD: ttykbd.c,v 1.18 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * Name: MG 2a * Terminfo keyboard driver using key files * Created: 22-Nov-1987 Mic Kaczmarczik (mic@emx.cc.utexas.edu) */ #include #include #include #include #include #include "def.h" #include "kbd.h" /* * Get keyboard character. Very simple if you use keymaps and keys files. */ char *keystrings[] = {NULL}; /* * Turn on function keys using keypad_xmit, then load a keys file, if * available. The keys file is located in the same manner as the startup * file is, depending on what startupfile() does on your system. */ void ttykeymapinit(void) { char *cp; /* Bind keypad function keys. */ if (key_left) dobindkey(fundamental_map, "backward-char", key_left); if (key_right) dobindkey(fundamental_map, "forward-char", key_right); if (key_up) dobindkey(fundamental_map, "previous-line", key_up); if (key_down) dobindkey(fundamental_map, "next-line", key_down); if (key_beg) dobindkey(fundamental_map, "beginning-of-line", key_beg); else if (key_home) dobindkey(fundamental_map, "beginning-of-line", key_home); if (key_end) dobindkey(fundamental_map, "end-of-line", key_end); if (key_npage) dobindkey(fundamental_map, "scroll-up", key_npage); if (key_ppage) dobindkey(fundamental_map, "scroll-down", key_ppage); if (key_dc) dobindkey(fundamental_map, "delete-char", key_dc); if ((cp = getenv("TERM"))) { if (((cp = startupfile(cp)) != NULL) && (load(cp) != TRUE)) ewprintf("Error reading key initialization file"); } if (keypad_xmit) /* turn on keypad */ putpad(keypad_xmit, 1); } /* * Clean up the keyboard -- called by tttidy() */ void ttykeymaptidy(void) { if (keypad_local) /* turn off keypad */ putpad(keypad_local, 1); } mg-20161005/undo.c010064400017510001751000000275121276555461200123660ustar00hanboetes/* $OpenBSD: undo.c,v 1.58 2016/09/05 08:10:58 lum Exp $ */ /* * This file is in the public domain */ #include #include #include #include #include #include "def.h" #include "kbd.h" #define MAX_FREE_RECORDS 32 /* * Local variables */ static struct undoq undo_free; static int undo_free_num; static int boundary_flag = TRUE; static int undo_enable_flag = TRUE; /* * Local functions */ static int find_dot(struct line *, int); static int find_lo(int, struct line **, int *, int *); static struct undo_rec *new_undo_record(void); static int drop_oldest_undo_record(void); /* * find_dot, find_lo() * * Find an absolute dot in the buffer from a line/offset pair, and vice-versa. * * Since lines can be deleted while they are referenced by undo record, we * need to have an absolute dot to have something reliable. */ static int find_dot(struct line *lp, int off) { int count = 0; struct line *p; for (p = curbp->b_headp; p != lp; p = lforw(p)) { if (count != 0) { if (p == curbp->b_headp) { dobeep(); ewprintf("Error: Undo stuff called with a" "nonexistent line"); return (FALSE); } } count += llength(p) + 1; } count += off; return (count); } static int find_lo(int pos, struct line **olp, int *offset, int *lnum) { struct line *p; int lineno; p = curbp->b_headp; lineno = 0; while (pos > llength(p)) { pos -= llength(p) + 1; if ((p = lforw(p)) == curbp->b_headp) { *olp = NULL; *offset = 0; return (FALSE); } lineno++; } *olp = p; *offset = pos; *lnum = lineno; return (TRUE); } static struct undo_rec * new_undo_record(void) { struct undo_rec *rec; rec = TAILQ_FIRST(&undo_free); if (rec != NULL) { /* Remove it from the free-list */ TAILQ_REMOVE(&undo_free, rec, next); undo_free_num--; } else { if ((rec = malloc(sizeof(*rec))) == NULL) panic("Out of memory in undo code (record)"); } memset(rec, 0, sizeof(struct undo_rec)); return (rec); } void free_undo_record(struct undo_rec *rec) { static int initialised = 0; /* * On the first run, do initialisation of the free list. */ if (initialised == 0) { TAILQ_INIT(&undo_free); initialised = 1; } free(rec->content); rec->content = NULL; if (undo_free_num >= MAX_FREE_RECORDS) { free(rec); return; } undo_free_num++; TAILQ_INSERT_HEAD(&undo_free, rec, next); } /* * Drop the oldest undo record in our list. Return 1 if we could remove it, * 0 if the undo list was empty. */ static int drop_oldest_undo_record(void) { struct undo_rec *rec; rec = TAILQ_LAST(&curbp->b_undo, undoq); if (rec != NULL) { undo_free_num--; TAILQ_REMOVE(&curbp->b_undo, rec, next); free_undo_record(rec); return (1); } return (0); } static int lastrectype(void) { struct undo_rec *rec; if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL) return (rec->type); return (0); } /* * Returns TRUE if undo is enabled, FALSE otherwise. */ int undo_enabled(void) { return (undo_enable_flag); } /* * undo_enable: toggle undo_enable. * Returns the previous value of the flag. */ int undo_enable(int f, int n) { int pon = undo_enable_flag; if (f & (FFARG | FFRAND)) undo_enable_flag = n > 0; else undo_enable_flag = !undo_enable_flag; if (!(f & FFRAND)) ewprintf("Undo %sabled", undo_enable_flag ? "en" : "dis"); return (pon); } /* * If undo is enabled, then: * Toggle undo boundary recording. * If called with an argument, (n > 0) => enable. Otherwise disable. * In either case, add an undo boundary * If undo is disabled, this function has no effect. */ int undo_boundary_enable(int f, int n) { int bon = boundary_flag; if (!undo_enable_flag) return (FALSE); undo_add_boundary(FFRAND, 1); if (f & (FFARG | FFRAND)) boundary_flag = n > 0; else boundary_flag = !boundary_flag; if (!(f & FFRAND)) ewprintf("Undo boundaries %sabled", boundary_flag ? "en" : "dis"); return (bon); } /* * Record an undo boundary, unless boundary_flag == FALSE. * Does nothing if previous undo entry is already a boundary or 'modified' flag. */ int undo_add_boundary(int f, int n) { struct undo_rec *rec; int last; if (boundary_flag == FALSE) return (FALSE); last = lastrectype(); if (last == BOUNDARY || last == MODIFIED) return (TRUE); rec = new_undo_record(); rec->type = BOUNDARY; TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next); return (TRUE); } /* * Record an undo "modified" boundary */ void undo_add_modified(void) { struct undo_rec *rec, *trec; TAILQ_FOREACH_SAFE(rec, &curbp->b_undo, next, trec) if (rec->type == MODIFIED) { TAILQ_REMOVE(&curbp->b_undo, rec, next); free_undo_record(rec); } rec = new_undo_record(); rec->type = MODIFIED; TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next); return; } int undo_add_insert(struct line *lp, int offset, int size) { struct region reg; struct undo_rec *rec; int pos; if (!undo_enable_flag) return (TRUE); memset(®, 0, sizeof(reg)); reg.r_linep = lp; reg.r_offset = offset; reg.r_size = size; pos = find_dot(lp, offset); /* * We try to reuse the last undo record to `compress' things. */ rec = TAILQ_FIRST(&curbp->b_undo); if (rec != NULL && rec->type == INSERT) { if (rec->pos + rec->region.r_size == pos) { rec->region.r_size += reg.r_size; return (TRUE); } } /* * We couldn't reuse the last undo record, so prepare a new one. */ rec = new_undo_record(); rec->pos = pos; rec->type = INSERT; memmove(&rec->region, ®, sizeof(struct region)); rec->content = NULL; undo_add_boundary(FFRAND, 1); TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next); return (TRUE); } /* * This of course must be done _before_ the actual deletion is done. */ int undo_add_delete(struct line *lp, int offset, int size, int isreg) { struct region reg; struct undo_rec *rec; int pos; if (!undo_enable_flag) return (TRUE); memset(®, 0, sizeof(reg)); reg.r_linep = lp; reg.r_offset = offset; reg.r_size = size; pos = find_dot(lp, offset); if (offset == llength(lp)) /* if it's a newline... */ undo_add_boundary(FFRAND, 1); else if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL) { /* * Separate this command from the previous one if we're not * just before the previous record... */ if (!isreg && rec->type == DELETE) { if (rec->pos - rec->region.r_size != pos) undo_add_boundary(FFRAND, 1); } } rec = new_undo_record(); rec->pos = pos; if (isreg) rec->type = DELREG; else rec->type = DELETE; memmove(&rec->region, ®, sizeof(struct region)); do { rec->content = malloc(reg.r_size + 1); } while ((rec->content == NULL) && drop_oldest_undo_record()); if (rec->content == NULL) panic("Out of memory"); region_get_data(®, rec->content, reg.r_size); if (isreg || lastrectype() != DELETE) undo_add_boundary(FFRAND, 1); TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next); return (TRUE); } /* * This of course must be called before the change takes place. */ int undo_add_change(struct line *lp, int offset, int size) { if (!undo_enable_flag) return (TRUE); undo_add_boundary(FFRAND, 1); boundary_flag = FALSE; undo_add_delete(lp, offset, size, 0); undo_add_insert(lp, offset, size); boundary_flag = TRUE; undo_add_boundary(FFRAND, 1); return (TRUE); } /* * Show the undo records for the current buffer in a new buffer. */ /* ARGSUSED */ int undo_dump(int f, int n) { struct undo_rec *rec; struct buffer *bp; struct mgwin *wp; char buf[4096], tmp[1024]; int num; /* * Prepare the buffer for insertion. */ if ((bp = bfind("*undo*", TRUE)) == NULL) return (FALSE); bp->b_flag |= BFREADONLY; bclear(bp); if ((wp = popbuf(bp, WNONE)) == NULL) return (FALSE); for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == bp) { wp->w_dotp = bp->b_headp; wp->w_doto = 0; } } num = 0; TAILQ_FOREACH(rec, &curbp->b_undo, next) { num++; snprintf(buf, sizeof(buf), "%d:\t %s at %d ", num, (rec->type == DELETE) ? "DELETE": (rec->type == DELREG) ? "DELREGION": (rec->type == INSERT) ? "INSERT": (rec->type == BOUNDARY) ? "----" : (rec->type == MODIFIED) ? "MODIFIED": "UNKNOWN", rec->pos); if (rec->content) { (void)strlcat(buf, "\"", sizeof(buf)); snprintf(tmp, sizeof(tmp), "%.*s", rec->region.r_size, rec->content); (void)strlcat(buf, tmp, sizeof(buf)); (void)strlcat(buf, "\"", sizeof(buf)); } snprintf(tmp, sizeof(tmp), " [%d]", rec->region.r_size); if (strlcat(buf, tmp, sizeof(buf)) >= sizeof(buf)) { dobeep(); ewprintf("Undo record too large. Aborted."); return (FALSE); } addlinef(bp, "%s", buf); } for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == bp) { wp->w_dotline = num+1; wp->w_rflag |= WFFULL; } } return (TRUE); } /* * After the user did action1, then action2, then action3: * * [action3] <--- Undoptr * [action2] * [action1] * ------ * [undo] * * After undo: * * [undo of action3] * [action2] <--- Undoptr * [action1] * ------ * [undo] * * After another undo: * * * [undo of action2] * [undo of action3] * [action1] <--- Undoptr * ------ * [undo] * * Note that the "undo of actionX" have no special meaning. Only when * we undo a deletion, the insertion will be recorded just as if it * was typed on the keyboard. Resulting in the inverse operation being * saved in the list. * * If undoptr reaches the bottom of the list, or if we moved between * two undo actions, we make it point back at the topmost record. This is * how we handle redoing. */ /* ARGSUSED */ int undo(int f, int n) { struct undo_rec *ptr, *nptr; int done, rval; struct line *lp; int offset, save; static int nulled = FALSE; int lineno; if (n < 0) return (FALSE); ptr = curbp->b_undoptr; /* first invocation, make ptr point back to the top of the list */ if ((ptr == NULL && nulled == TRUE) || rptcount == 0) { ptr = TAILQ_FIRST(&curbp->b_undo); nulled = TRUE; } rval = TRUE; while (n--) { /* if we have a spurious boundary, free it and move on.... */ while (ptr && ptr->type == BOUNDARY) { nptr = TAILQ_NEXT(ptr, next); TAILQ_REMOVE(&curbp->b_undo, ptr, next); free_undo_record(ptr); ptr = nptr; } /* * Ptr is NULL, but on the next run, it will point to the * top again, redoing all stuff done in the buffer since * its creation. */ if (ptr == NULL) { dobeep(); ewprintf("No further undo information"); rval = FALSE; nulled = TRUE; break; } nulled = FALSE; /* * Loop while we don't get a boundary specifying we've * finished the current action... */ undo_add_boundary(FFRAND, 1); save = boundary_flag; boundary_flag = FALSE; done = 0; do { /* * Move to where this has to apply * * Boundaries (and the modified flag) are put as * position 0 (to save lookup time in find_dot) * so we must not move there... */ if (ptr->type != BOUNDARY && ptr->type != MODIFIED) { if (find_lo(ptr->pos, &lp, &offset, &lineno) == FALSE) { dobeep(); ewprintf("Internal error in Undo!"); rval = FALSE; break; } curwp->w_dotp = lp; curwp->w_doto = offset; curwp->w_markline = curwp->w_dotline; curwp->w_dotline = lineno; } /* * Do operation^-1 */ switch (ptr->type) { case INSERT: ldelete(ptr->region.r_size, KNONE); break; case DELETE: lp = curwp->w_dotp; offset = curwp->w_doto; region_put_data(ptr->content, ptr->region.r_size); curwp->w_dotp = lp; curwp->w_doto = offset; break; case DELREG: region_put_data(ptr->content, ptr->region.r_size); break; case BOUNDARY: done = 1; break; case MODIFIED: curbp->b_flag &= ~BFCHG; break; default: break; } /* And move to next record */ ptr = TAILQ_NEXT(ptr, next); } while (ptr != NULL && !done); boundary_flag = save; undo_add_boundary(FFRAND, 1); ewprintf("Undo!"); } curbp->b_undoptr = ptr; return (rval); } mg-20161005/util.c010064400017510001751000000250471276204442100123640ustar00hanboetes/* $OpenBSD: util.c,v 1.38 2015/11/18 18:21:06 jasper Exp $ */ /* This file is in the public domain. */ /* * Assorted commands. * This file contains the command processors for a large assortment of * unrelated commands. The only thing they have in common is that they * are all command processors. */ #include #include #include #include #include "def.h" /* * Display a bunch of useful information about the current location of dot. * The character under the cursor (in octal), the current line, row, and * column, and approximate position of the cursor in the file (as a * percentage) is displayed. The column position assumes an infinite * position display; it does not truncate just because the screen does. * This is normally bound to "C-X =". */ /* ARGSUSED */ int showcpos(int f, int n) { struct line *clp; long nchar, cchar; int nline, row; int cline, cbyte; /* Current line/char/byte */ int ratio; /* collect the data */ clp = bfirstlp(curbp); cchar = 0; cline = 0; cbyte = 0; nchar = 0; nline = 0; for (;;) { /* count this line */ ++nline; if (clp == curwp->w_dotp) { /* mark line */ cline = nline; cchar = nchar + curwp->w_doto; if (curwp->w_doto == llength(clp)) cbyte = '\n'; else cbyte = lgetc(clp, curwp->w_doto); } /* now count the chars */ nchar += llength(clp); clp = lforw(clp); if (clp == curbp->b_headp) break; /* count the newline */ nchar++; } /* determine row */ row = curwp->w_toprow + 1; clp = curwp->w_linep; while (clp != curbp->b_headp && clp != curwp->w_dotp) { ++row; clp = lforw(clp); } ratio = nchar ? (100L * cchar) / nchar : 100; ewprintf("Char: %c (0%o) point=%ld(%d%%) line=%d row=%d col=%d", cbyte, cbyte, cchar, ratio, cline, row, getcolpos(curwp)); return (TRUE); } int getcolpos(struct mgwin *wp) { int col, i, c; char tmp[5]; /* determine column */ col = 0; for (i = 0; i < wp->w_doto; ++i) { c = lgetc(wp->w_dotp, i); if (c == '\t' #ifdef NOTAB && !(wp->w_bufp->b_flag & BFNOTAB) #endif /* NOTAB */ ) { col |= 0x07; col++; } else if (ISCTRL(c) != FALSE) col += 2; else if (isprint(c)) { col++; } else { col += snprintf(tmp, sizeof(tmp), "\\%o", c); } } return (col); } /* * Twiddle the two characters in front of and under dot, then move forward * one character. Treat new-line characters the same as any other. * Normally bound to "C-t". This always works within a line, so "WFEDIT" * is good enough. */ /* ARGSUSED */ int twiddle(int f, int n) { struct line *dotp; int doto, cr; if (n == 0) return (TRUE); dotp = curwp->w_dotp; doto = curwp->w_doto; /* Don't twiddle if the dot is on the first char of buffer */ if (doto == 0 && lback(dotp) == curbp->b_headp) { dobeep(); ewprintf("Beginning of buffer"); return(FALSE); } /* Don't twiddle if the dot is on the last char of buffer */ if (doto == llength(dotp) && lforw(dotp) == curbp->b_headp) { dobeep(); return(FALSE); } undo_boundary_enable(FFRAND, 0); if (doto == 0 && doto == llength(dotp)) { /* only '\n' on this line */ (void)forwline(FFRAND, 1); curwp->w_doto = 0; } else { if (doto == 0) { /* 1st twiddle is on 1st character of a line */ cr = lgetc(dotp, doto); (void)backdel(FFRAND, 1); (void)forwchar(FFRAND, 1); lnewline(); linsert(1, cr); (void)backdel(FFRAND, 1); } else { /* twiddle is elsewhere in line */ cr = lgetc(dotp, doto - 1); (void)backdel(FFRAND, 1); (void)forwchar(FFRAND, 1); linsert(1, cr); } } undo_boundary_enable(FFRAND, 1); lchange(WFEDIT); return (TRUE); } /* * Open up some blank space. The basic plan is to insert a bunch of * newlines, and then back up over them. Everything is done by the * subcommand processors. They even handle the looping. Normally this * is bound to "C-O". */ /* ARGSUSED */ int openline(int f, int n) { int i, s; if (n < 0) return (FALSE); if (n == 0) return (TRUE); /* insert newlines */ undo_boundary_enable(FFRAND, 0); i = n; do { s = lnewline(); } while (s == TRUE && --i); /* then go back up overtop of them all */ if (s == TRUE) s = backchar(f | FFRAND, n); undo_boundary_enable(FFRAND, 1); return (s); } /* * Insert a newline. */ /* ARGSUSED */ int enewline(int f, int n) { int s; if (n < 0) return (FALSE); while (n--) { if ((s = lnewline()) != TRUE) return (s); } return (TRUE); } /* * Delete blank lines around dot. What this command does depends if dot is * sitting on a blank line. If dot is sitting on a blank line, this command * deletes all the blank lines above and below the current line. If it is * sitting on a non blank line then it deletes all of the blank lines after * the line. Normally this command is bound to "C-X C-O". Any argument is * ignored. */ /* ARGSUSED */ int deblank(int f, int n) { struct line *lp1, *lp2; RSIZE nld; lp1 = curwp->w_dotp; while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_headp) lp1 = lp2; lp2 = lp1; nld = (RSIZE)0; while ((lp2 = lforw(lp2)) != curbp->b_headp && llength(lp2) == 0) ++nld; if (nld == 0) return (TRUE); curwp->w_dotp = lforw(lp1); curwp->w_doto = 0; return (ldelete((RSIZE)nld, KNONE)); } /* * Delete any whitespace around dot, then insert a space. */ int justone(int f, int n) { undo_boundary_enable(FFRAND, 0); (void)delwhite(f, n); linsert(1, ' '); undo_boundary_enable(FFRAND, 1); return (TRUE); } /* * Delete any whitespace around dot. */ /* ARGSUSED */ int delwhite(int f, int n) { int col, s; col = curwp->w_doto; while (col < llength(curwp->w_dotp) && (isspace(lgetc(curwp->w_dotp, col)))) ++col; do { if (curwp->w_doto == 0) { s = FALSE; break; } if ((s = backchar(FFRAND, 1)) != TRUE) break; } while (isspace(lgetc(curwp->w_dotp, curwp->w_doto))); if (s == TRUE) (void)forwchar(FFRAND, 1); (void)ldelete((RSIZE)(col - curwp->w_doto), KNONE); return (TRUE); } /* * Delete any leading whitespace on the current line */ int delleadwhite(int f, int n) { int soff, ls; struct line *slp; /* Save current position */ slp = curwp->w_dotp; soff = curwp->w_doto; for (ls = 0; ls < llength(slp); ls++) if (!isspace(lgetc(slp, ls))) break; gotobol(FFRAND, 1); forwdel(FFRAND, ls); soff -= ls; if (soff < 0) soff = 0; forwchar(FFRAND, soff); return (TRUE); } /* * Delete any trailing whitespace on the current line */ int deltrailwhite(int f, int n) { int soff; /* Save current position */ soff = curwp->w_doto; gotoeol(FFRAND, 1); delwhite(FFRAND, 1); /* restore original position, if possible */ if (soff < curwp->w_doto) curwp->w_doto = soff; return (TRUE); } /* * Insert a newline, then enough tabs and spaces to duplicate the indentation * of the previous line. Assumes tabs are every eight characters. Quite * simple. Figure out the indentation of the current line. Insert a newline * by calling the standard routine. Insert the indentation by inserting the * right number of tabs and spaces. Return TRUE if all ok. Return FALSE if * one of the subcommands failed. Normally bound to "C-M". */ /* ARGSUSED */ int lfindent(int f, int n) { int c, i, nicol; int s = TRUE; if (n < 0) return (FALSE); undo_boundary_enable(FFRAND, 0); while (n--) { nicol = 0; for (i = 0; i < llength(curwp->w_dotp); ++i) { c = lgetc(curwp->w_dotp, i); if (c != ' ' && c != '\t') break; if (c == '\t') nicol |= 0x07; ++nicol; } if (lnewline() == FALSE || (( #ifdef NOTAB curbp->b_flag & BFNOTAB) ? linsert(nicol, ' ') == FALSE : ( #endif /* NOTAB */ ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) || ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE)))) { s = FALSE; break; } } undo_boundary_enable(FFRAND, 1); return (s); } /* * Indent the current line. Delete existing leading whitespace, * and use tabs/spaces to achieve correct indentation. Try * to leave dot where it started. */ int indent(int f, int n) { int soff, i; if (n < 0) return (FALSE); delleadwhite(FFRAND, 1); /* If not invoked with a numerical argument, done */ if (!(f & FFARG)) return (TRUE); /* insert appropriate whitespace */ soff = curwp->w_doto; (void)gotobol(FFRAND, 1); if ( #ifdef NOTAB (curbp->b_flag & BFNOTAB) ? linsert(n, ' ') == FALSE : #endif /* NOTAB */ (((i = n / 8) != 0 && linsert(i, '\t') == FALSE) || ((i = n % 8) != 0 && linsert(i, ' ') == FALSE))) return (FALSE); forwchar(FFRAND, soff); return (TRUE); } /* * Delete forward. This is real easy, because the basic delete routine does * all of the work. Watches for negative arguments, and does the right thing. * If any argument is present, it kills rather than deletes, to prevent loss * of text if typed with a big argument. Normally bound to "C-D". */ /* ARGSUSED */ int forwdel(int f, int n) { if (n < 0) return (backdel(f | FFRAND, -n)); /* really a kill */ if (f & FFARG) { if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; } return (ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE)); } /* * Delete backwards. This is quite easy too, because it's all done with * other functions. Just move the cursor back, and delete forwards. Like * delete forward, this actually does a kill if presented with an argument. */ /* ARGSUSED */ int backdel(int f, int n) { int s; if (n < 0) return (forwdel(f | FFRAND, -n)); /* really a kill */ if (f & FFARG) { if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; } if ((s = backchar(f | FFRAND, n)) == TRUE) s = ldelete((RSIZE)n, (f & FFARG) ? KFORW : KNONE); return (s); } #ifdef NOTAB /* ARGSUSED */ int space_to_tabstop(int f, int n) { if (n < 0) return (FALSE); if (n == 0) return (TRUE); return (linsert((n << 3) - (curwp->w_doto & 7), ' ')); } #endif /* NOTAB */ /* * Move the dot to the first non-whitespace character of the current line. */ int backtoindent(int f, int n) { gotobol(FFRAND, 1); while (curwp->w_doto < llength(curwp->w_dotp) && (isspace(lgetc(curwp->w_dotp, curwp->w_doto)))) ++curwp->w_doto; return (TRUE); } /* * Join the current line to the previous, or with arg, the next line * to the current one. If the former line is not empty, leave exactly * one space at the joint. Otherwise, leave no whitespace. */ int joinline(int f, int n) { int doto; undo_boundary_enable(FFRAND, 0); if (f & FFARG) { gotoeol(FFRAND, 1); forwdel(FFRAND, 1); } else { gotobol(FFRAND, 1); backdel(FFRAND, 1); } delwhite(FFRAND, 1); if ((doto = curwp->w_doto) > 0) { linsert(1, ' '); curwp->w_doto = doto; } undo_boundary_enable(FFRAND, 1); return (TRUE); } mg-20161005/version.c010064400017510001751000000007721276204442100130720ustar00hanboetes/* $OpenBSD: version.c,v 1.10 2015/03/19 21:22:15 bcallah Exp $ */ /* This file is in the public domain. */ /* * This file contains the string that gets written * out by the emacs-version command. */ #include #include #include #include "def.h" const char version[] = "Mg 2a"; /* * Display the version. All this does * is copy the version string onto the echo line. */ /* ARGSUSED */ int showversion(int f, int n) { ewprintf("%s", version); return (TRUE); } mg-20161005/window.c010064400017510001751000000236331276204442100127150ustar00hanboetes/* $OpenBSD: window.c,v 1.36 2015/11/18 18:21:06 jasper Exp $ */ /* This file is in the public domain. */ /* * Window handling. */ #include #include #include #include #include "def.h" struct mgwin * new_window(struct buffer *bp) { struct mgwin *wp; wp = calloc(1, sizeof(struct mgwin)); if (wp == NULL) return (NULL); wp->w_bufp = bp; wp->w_dotp = NULL; wp->w_doto = 0; wp->w_markp = NULL; wp->w_marko = 0; wp->w_rflag = 0; wp->w_frame = 0; wp->w_wrapline = NULL; wp->w_dotline = wp->w_markline = 1; if (bp) bp->b_nwnd++; return (wp); } /* * Reposition dot in the current window to line "n". If the argument is * positive, it is that line. If it is negative it is that line from the * bottom. If it is 0 the window is centered (this is what the standard * redisplay code does). */ /* ARGSUSED */ int reposition(int f, int n) { curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0; curwp->w_rflag |= WFFRAME; sgarbf = TRUE; return (TRUE); } /* * Refresh the display. A call is made to the "ttresize" entry in the * terminal handler, which tries to reset "nrow" and "ncol". They will, * however, never be set outside of the NROW or NCOL range. If the display * changed size, arrange that everything is redone, then call "update" to * fix the display. We do this so the new size can be displayed. In the * normal case the call to "update" in "main.c" refreshes the screen, and * all of the windows need not be recomputed. This call includes a * 'force' parameter to ensure that the redraw is done, even after a * a suspend/continue (where the window size parameters will already * be updated). Note that when you get to the "display unusable" * message, the screen will be messed up. If you make the window bigger * again, and send another command, everything will get fixed! */ int redraw(int f, int n) { return (do_redraw(f, n, FALSE)); } /* ARGSUSED */ int do_redraw(int f, int n, int force) { struct mgwin *wp; int oldnrow, oldncol; oldnrow = nrow; oldncol = ncol; ttresize(); if (nrow != oldnrow || ncol != oldncol || force) { /* find last */ wp = wheadp; while (wp->w_wndp != NULL) wp = wp->w_wndp; /* check if too small */ if (nrow < wp->w_toprow + 3) { dobeep(); ewprintf("Display unusable"); return (FALSE); } wp->w_ntrows = nrow - wp->w_toprow - 2; sgarbf = TRUE; update(CMODE); } else sgarbf = TRUE; return (TRUE); } /* * The command to make the next window (next => down the screen) the current * window. There are no real errors, although the command does nothing if * there is only 1 window on the screen. */ /* ARGSUSED */ int nextwind(int f, int n) { struct mgwin *wp; if ((wp = curwp->w_wndp) == NULL) wp = wheadp; curwp = wp; curbp = wp->w_bufp; return (TRUE); } /* not in GNU Emacs */ /* * This command makes the previous window (previous => up the screen) the * current window. There are no errors, although the command does not do * a lot if there is only 1 window. */ /* ARGSUSED */ int prevwind(int f, int n) { struct mgwin *wp1, *wp2; wp1 = wheadp; wp2 = curwp; if (wp1 == wp2) wp2 = NULL; while (wp1->w_wndp != wp2) wp1 = wp1->w_wndp; curwp = wp1; curbp = wp1->w_bufp; return (TRUE); } /* * This command makes the current window the only window on the screen. Try * to set the framing so that "." does not have to move on the display. Some * care has to be taken to keep the values of dot and mark in the buffer * structures right if the destruction of a window makes a buffer become * undisplayed. */ /* ARGSUSED */ int onlywind(int f, int n) { struct mgwin *wp; struct line *lp; int i; while (wheadp != curwp) { wp = wheadp; wheadp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; wp->w_bufp->b_dotline = wp->w_dotline; wp->w_bufp->b_markline = wp->w_markline; } free(wp); } while (curwp->w_wndp != NULL) { wp = curwp->w_wndp; curwp->w_wndp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; wp->w_bufp->b_dotline = wp->w_dotline; wp->w_bufp->b_markline = wp->w_markline; } free(wp); } lp = curwp->w_linep; i = curwp->w_toprow; while (i != 0 && lback(lp) != curbp->b_headp) { --i; lp = lback(lp); } curwp->w_toprow = 0; /* 2 = mode, echo */ curwp->w_ntrows = nrow - 2; curwp->w_linep = lp; curwp->w_rflag |= WFMODE | WFFULL; return (TRUE); } /* * Split the current window. A window smaller than 3 lines cannot be split. * The only other error that is possible is a "malloc" failure allocating the * structure for the new window. * If called with a FFOTHARG, flags on the new window are set to 'n'. */ /* ARGSUSED */ int splitwind(int f, int n) { struct mgwin *wp, *wp1, *wp2; struct line *lp; int ntru, ntrd, ntrl; if (curwp->w_ntrows < 3) { dobeep(); ewprintf("Cannot split a %d line window", curwp->w_ntrows); return (FALSE); } wp = new_window(curbp); if (wp == NULL) { dobeep(); ewprintf("Unable to create a window"); return (FALSE); } /* use the current dot and mark */ wp->w_dotp = curwp->w_dotp; wp->w_doto = curwp->w_doto; wp->w_markp = curwp->w_markp; wp->w_marko = curwp->w_marko; wp->w_dotline = curwp->w_dotline; wp->w_markline = curwp->w_markline; /* figure out which half of the screen we're in */ ntru = (curwp->w_ntrows - 1) / 2; /* Upper size */ ntrl = (curwp->w_ntrows - 1) - ntru; /* Lower size */ for (lp = curwp->w_linep, ntrd = 0; lp != curwp->w_dotp; lp = lforw(lp)) ntrd++; lp = curwp->w_linep; /* old is upper window */ if (ntrd <= ntru) { /* hit mode line */ if (ntrd == ntru) lp = lforw(lp); curwp->w_ntrows = ntru; wp->w_wndp = curwp->w_wndp; curwp->w_wndp = wp; wp->w_toprow = curwp->w_toprow + ntru + 1; wp->w_ntrows = ntrl; /* old is lower window */ } else { wp1 = NULL; wp2 = wheadp; while (wp2 != curwp) { wp1 = wp2; wp2 = wp2->w_wndp; } if (wp1 == NULL) wheadp = wp; else wp1->w_wndp = wp; wp->w_wndp = curwp; wp->w_toprow = curwp->w_toprow; wp->w_ntrows = ntru; /* mode line */ ++ntru; curwp->w_toprow += ntru; curwp->w_ntrows = ntrl; while (ntru--) lp = lforw(lp); } /* adjust the top lines if necessary */ curwp->w_linep = lp; wp->w_linep = lp; curwp->w_rflag |= WFMODE | WFFULL; wp->w_rflag |= WFMODE | WFFULL; /* if FFOTHARG, set flags) */ if (f & FFOTHARG) wp->w_flag = n; return (TRUE); } /* * Enlarge the current window. Find the window that loses space. Make sure * it is big enough. If so, hack the window descriptions, and ask redisplay * to do all the hard work. You don't just set "force reframe" because dot * would move. */ /* ARGSUSED */ int enlargewind(int f, int n) { struct mgwin *adjwp; struct line *lp; int i; if (n < 0) return (shrinkwind(f, -n)); if (wheadp->w_wndp == NULL) { dobeep(); ewprintf("Only one window"); return (FALSE); } if ((adjwp = curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; } if (adjwp->w_ntrows <= n) { dobeep(); ewprintf("Impossible change"); return (FALSE); } /* shrink below */ if (curwp->w_wndp == adjwp) { lp = adjwp->w_linep; for (i = 0; i < n && lp != adjwp->w_bufp->b_headp; ++i) lp = lforw(lp); adjwp->w_linep = lp; adjwp->w_toprow += n; /* shrink above */ } else { lp = curwp->w_linep; for (i = 0; i < n && lback(lp) != curbp->b_headp; ++i) lp = lback(lp); curwp->w_linep = lp; curwp->w_toprow -= n; } curwp->w_ntrows += n; adjwp->w_ntrows -= n; curwp->w_rflag |= WFMODE | WFFULL; adjwp->w_rflag |= WFMODE | WFFULL; return (TRUE); } /* * Shrink the current window. Find the window that gains space. Hack at the * window descriptions. Ask the redisplay to do all the hard work. */ int shrinkwind(int f, int n) { struct mgwin *adjwp; struct line *lp; int i; if (n < 0) return (enlargewind(f, -n)); if (wheadp->w_wndp == NULL) { dobeep(); ewprintf("Only one window"); return (FALSE); } /* * Bit of flakiness - FFRAND means it was an internal call, and * to be trusted implicitly about sizes. */ if (!(f & FFRAND) && curwp->w_ntrows <= n) { dobeep(); ewprintf("Impossible change"); return (FALSE); } if ((adjwp = curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; } /* grow below */ if (curwp->w_wndp == adjwp) { lp = adjwp->w_linep; for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_headp; ++i) lp = lback(lp); adjwp->w_linep = lp; adjwp->w_toprow -= n; /* grow above */ } else { lp = curwp->w_linep; for (i = 0; i < n && lp != curbp->b_headp; ++i) lp = lforw(lp); curwp->w_linep = lp; curwp->w_toprow += n; } curwp->w_ntrows -= n; adjwp->w_ntrows += n; curwp->w_rflag |= WFMODE | WFFULL; adjwp->w_rflag |= WFMODE | WFFULL; return (TRUE); } /* * Delete current window. Call shrink-window to do the screen updating, then * throw away the window. */ /* ARGSUSED */ int delwind(int f, int n) { struct mgwin *wp, *nwp; wp = curwp; /* Cheap... */ /* shrinkwind returning false means only one window... */ if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE) return (FALSE); if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; wp->w_bufp->b_dotline = wp->w_dotline; wp->w_bufp->b_markline = wp->w_markline; } /* since shrinkwind did't crap out, we know we have a second window */ if (wp == wheadp) wheadp = curwp = wp->w_wndp; else if ((curwp = wp->w_wndp) == NULL) curwp = wheadp; curbp = curwp->w_bufp; for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp) if (nwp->w_wndp == wp) { nwp->w_wndp = wp->w_wndp; break; } free(wp); return (TRUE); } mg-20161005/word.c010064400017510001751000000243211276204442100123540ustar00hanboetes/* $OpenBSD: word.c,v 1.19 2015/12/30 20:51:51 lum Exp $ */ /* This file is in the public domain. */ /* * Word mode commands. * The routines in this file implement commands that work word at a time. * There are all sorts of word mode commands. */ #include #include #include #include #include #include #include "def.h" RSIZE countfword(void); int grabword(char **); /* * Move the cursor backward by "n" words. All of the details of motion are * performed by the "backchar" and "forwchar" routines. */ /* ARGSUSED */ int backword(int f, int n) { if (n < 0) return (forwword(f | FFRAND, -n)); if (backchar(FFRAND, 1) == FALSE) return (FALSE); while (n--) { while (inword() == FALSE) { if (backchar(FFRAND, 1) == FALSE) return (TRUE); } while (inword() != FALSE) { if (backchar(FFRAND, 1) == FALSE) return (TRUE); } } return (forwchar(FFRAND, 1)); } /* * Move the cursor forward by the specified number of words. All of the * motion is done by "forwchar". */ /* ARGSUSED */ int forwword(int f, int n) { if (n < 0) return (backword(f | FFRAND, -n)); while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } while (inword() != FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } } return (TRUE); } /* * Transpose 2 words. * The function below is artifically restricted to only a maximum of 1 iteration * at the moment because the 'undo' functionality within mg needs amended for * multiple movements of point, backwards and forwards. */ int transposeword(int f, int n) { struct line *tmp1_w_dotp = NULL; struct line *tmp2_w_dotp = NULL; int tmp2_w_doto = 0; int tmp1_w_dotline = 0; int tmp2_w_dotline = 0; int tmp1_w_doto; int i; /* start-of-line space counter */ int ret, s; int newline; int leave = 0; int tmp_len; char *word1 = NULL; char *word2 = NULL; char *chr; if (n == 0) return (TRUE); n = 1; /* remove this line to allow muliple-iterations */ if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } undo_boundary_enable(FFRAND, 0); /* go backwards to find the start of a word to transpose. */ (void)backword(FFRAND, 1); ret = grabword(&word1); if (ret == ABORT) { ewprintf("No word to the left to tranpose."); return (FALSE); } if (ret < 0) { dobeep(); ewprintf("Error copying word: %s", strerror(ret)); free(word1); return (FALSE); } while (n-- > 0) { i = 0; newline = 0; tmp1_w_doto = curwp->w_doto; tmp1_w_dotline = curwp->w_dotline; tmp1_w_dotp = curwp->w_dotp; /* go forward and find next word. */ while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) { leave = 1; if (tmp1_w_dotline < curwp->w_dotline) curwp->w_dotline--; ewprintf("Don't have two things to transpose"); break; } if (curwp->w_doto == 0) { newline = 1; i = 0; } else if (newline) i++; } if (leave) { tmp2_w_doto = tmp1_w_doto; tmp2_w_dotline = tmp1_w_dotline; tmp2_w_dotp = tmp1_w_dotp; break; } tmp2_w_doto = curwp->w_doto; tmp2_w_dotline = curwp->w_dotline; tmp2_w_dotp = curwp->w_dotp; ret = grabword(&word2); if (ret < 0 || ret == ABORT) { dobeep(); ewprintf("Error copying word: %s", strerror(ret)); free(word1); return (FALSE); } tmp_len = strlen(word2); tmp2_w_doto += tmp_len; curwp->w_doto = tmp1_w_doto; curwp->w_dotline = tmp1_w_dotline; curwp->w_dotp = tmp1_w_dotp; /* insert shuffled along word */ for (chr = word2; *chr != '\0'; ++chr) linsert(1, *chr); if (newline) tmp2_w_doto = i; curwp->w_doto = tmp2_w_doto; curwp->w_dotline = tmp2_w_dotline; curwp->w_dotp = tmp2_w_dotp; word2 = NULL; } curwp->w_doto = tmp2_w_doto; curwp->w_dotline = tmp2_w_dotline; curwp->w_dotp = tmp2_w_dotp; /* insert very first word in its new position */ for (chr = word1; *chr != '\0'; ++chr) linsert(1, *chr); if (leave) (void)backword(FFRAND, 1); free(word1); free(word2); undo_boundary_enable(FFRAND, 1); return (TRUE); } /* * copy and delete word. */ int grabword(char **word) { int c; while (inword() == TRUE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (*word == NULL) { if (asprintf(word, "%c", c) == -1) return (errno); } else { if (asprintf(word, "%s%c", *word, c) == -1) return (errno); } (void)forwdel(FFRAND, 1); } if (*word == NULL) return (ABORT); return (TRUE); } /* * Move the cursor forward by the specified number of words. As you move, * convert any characters to upper case. */ /* ARGSUSED */ int upperword(int f, int n) { int c, s; RSIZE size; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } size = countfword(); undo_add_change(curwp->w_dotp, curwp->w_doto, size); while (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISLOWER(c) != FALSE) { c = TOUPPER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } } return (TRUE); } /* * Move the cursor forward by the specified number of words. As you move * convert characters to lower case. */ /* ARGSUSED */ int lowerword(int f, int n) { int c, s; RSIZE size; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } size = countfword(); undo_add_change(curwp->w_dotp, curwp->w_doto, size); while (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISUPPER(c) != FALSE) { c = TOLOWER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } } return (TRUE); } /* * Move the cursor forward by the specified number of words. As you move * convert the first character of the word to upper case, and subsequent * characters to lower case. Error if you try to move past the end of the * buffer. */ /* ARGSUSED */ int capword(int f, int n) { int c, s; RSIZE size; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } size = countfword(); undo_add_change(curwp->w_dotp, curwp->w_doto, size); if (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISLOWER(c) != FALSE) { c = TOUPPER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); while (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISUPPER(c) != FALSE) { c = TOLOWER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } } } return (TRUE); } /* * Count characters in word, from current position */ RSIZE countfword() { RSIZE size; struct line *dotp; int doto; dotp = curwp->w_dotp; doto = curwp->w_doto; size = 0; while (inword() != FALSE) { if (forwchar(FFRAND, 1) == FALSE) /* hit the end of the buffer */ goto out; ++size; } out: curwp->w_dotp = dotp; curwp->w_doto = doto; return (size); } /* * Kill forward by "n" words. */ /* ARGSUSED */ int delfword(int f, int n) { RSIZE size; struct line *dotp; int doto; int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); /* purge kill buffer */ if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; dotp = curwp->w_dotp; doto = curwp->w_doto; size = 0; while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) /* hit the end of the buffer */ goto out; ++size; } while (inword() != FALSE) { if (forwchar(FFRAND, 1) == FALSE) /* hit the end of the buffer */ goto out; ++size; } } out: curwp->w_dotp = dotp; curwp->w_doto = doto; return (ldelete(size, KFORW)); } /* * Kill backwards by "n" words. The rules for success and failure are now * different, to prevent strange behavior at the start of the buffer. The * command only fails if something goes wrong with the actual delete of the * characters. It is successful even if no characters are deleted, or if you * say delete 5 words, and there are only 4 words left. I considered making * the first call to "backchar" special, but decided that that would just be * weird. Normally this is bound to "M-Rubout" and to "M-Backspace". */ /* ARGSUSED */ int delbword(int f, int n) { RSIZE size; int s; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); /* purge kill buffer */ if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; if (backchar(FFRAND, 1) == FALSE) /* hit buffer start */ return (TRUE); /* one deleted */ size = 1; while (n--) { while (inword() == FALSE) { if (backchar(FFRAND, 1) == FALSE) /* hit buffer start */ goto out; ++size; } while (inword() != FALSE) { if (backchar(FFRAND, 1) == FALSE) /* hit buffer start */ goto out; ++size; } } if (forwchar(FFRAND, 1) == FALSE) return (FALSE); /* undo assumed delete */ --size; out: return (ldelete(size, KBACK)); } /* * Return TRUE if the character at dot is a character that is considered to be * part of a word. The word character list is hard coded. Should be settable. */ int inword(void) { /* can't use lgetc in ISWORD due to bug in OSK cpp */ return (curwp->w_doto != llength(curwp->w_dotp) && ISWORD(curwp->w_dotp->l_text[curwp->w_doto])); } mg-20161005/yank.c010064400017510001751000000147421276204442100123510ustar00hanboetes/* $OpenBSD: yank.c,v 1.14 2015/12/11 20:21:23 mmcc Exp $ */ /* This file is in the public domain. */ /* * kill ring functions */ #include #include #include #include #include #include "def.h" #define KBLOCK 8192 /* Kill grow. */ static char *kbufp = NULL; /* Kill buffer data. */ static RSIZE kused = 0; /* # of bytes used in KB. */ static RSIZE ksize = 0; /* # of bytes allocated in KB. */ static RSIZE kstart = 0; /* # of first used byte in KB. */ static int kgrow(int); /* * Delete all of the text saved in the kill buffer. Called by commands when * a new kill context is created. The kill buffer array is released, just in * case the buffer has grown to an immense size. No errors. */ void kdelete(void) { if (kbufp != NULL) { free(kbufp); kbufp = NULL; kstart = kused = ksize = 0; } } /* * Insert a character to the kill buffer, enlarging the buffer if there * isn't any room. Always grow the buffer in chunks, on the assumption * that if you put something in the kill buffer you are going to put more * stuff there too later. Return TRUE if all is well, and FALSE on errors. * Print a message on errors. Dir says whether to put it at back or front. * This call is ignored if KNONE is set. */ int kinsert(int c, int dir) { if (dir == KNONE) return (TRUE); if (kused == ksize && dir == KFORW && kgrow(dir) == FALSE) return (FALSE); if (kstart == 0 && dir == KBACK && kgrow(dir) == FALSE) return (FALSE); if (dir == KFORW) kbufp[kused++] = c; else if (dir == KBACK) kbufp[--kstart] = c; else panic("broken kinsert call"); /* Oh shit! */ return (TRUE); } /* * kgrow - just get more kill buffer for the callee. If dir = KBACK * we are trying to get space at the beginning of the kill buffer. */ static int kgrow(int dir) { int nstart; char *nbufp; if ((unsigned)(ksize + KBLOCK) <= (unsigned)ksize) { /* probably 16 bit unsigned */ dobeep(); ewprintf("Kill buffer size at maximum"); return (FALSE); } if ((nbufp = malloc((unsigned)(ksize + KBLOCK))) == NULL) { dobeep(); ewprintf("Can't get %ld bytes", (long)(ksize + KBLOCK)); return (FALSE); } nstart = (dir == KBACK) ? (kstart + KBLOCK) : (KBLOCK / 4); bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int)(kused - kstart)); free(kbufp); kbufp = nbufp; ksize += KBLOCK; kused = kused - kstart + nstart; kstart = nstart; return (TRUE); } /* * This function gets characters from the kill buffer. If the character * index "n" is off the end, it returns "-1". This lets the caller just * scan along until it gets a "-1" back. */ int kremove(int n) { if (n < 0 || n + kstart >= kused) return (-1); return (CHARMASK(kbufp[n + kstart])); } /* * Copy a string into the kill buffer. kflag gives direction. * if KNONE, do nothing. */ int kchunk(char *cp1, RSIZE chunk, int kflag) { /* * HACK - doesn't matter, and fixes back-over-nl bug for empty * kill buffers. */ if (kused == kstart) kflag = KFORW; if (kflag & KFORW) { while (ksize - kused < chunk) if (kgrow(kflag) == FALSE) return (FALSE); bcopy(cp1, &(kbufp[kused]), (int)chunk); kused += chunk; } else if (kflag & KBACK) { while (kstart < chunk) if (kgrow(kflag) == FALSE) return (FALSE); bcopy(cp1, &(kbufp[kstart - chunk]), (int)chunk); kstart -= chunk; } return (TRUE); } /* * Kill line. If called without an argument, it kills from dot to the end * of the line, unless it is at the end of the line, when it kills the * newline. If called with an argument of 0, it kills from the start of the * line to dot. If called with a positive argument, it kills from dot * forward over that number of newlines. If called with a negative argument * it kills any text before dot on the current line, then it kills back * abs(arg) lines. */ /* ARGSUSED */ int killline(int f, int n) { struct line *nextp; RSIZE chunk; int i, c; /* clear kill buffer if last wasn't a kill */ if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; if (!(f & FFARG)) { for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i) if ((c = lgetc(curwp->w_dotp, i)) != ' ' && c != '\t') break; if (i == llength(curwp->w_dotp)) chunk = llength(curwp->w_dotp) - curwp->w_doto + 1; else { chunk = llength(curwp->w_dotp) - curwp->w_doto; if (chunk == 0) chunk = 1; } } else if (n > 0) { chunk = llength(curwp->w_dotp) - curwp->w_doto; nextp = lforw(curwp->w_dotp); if (nextp != curbp->b_headp) chunk++; /* newline */ if (nextp == curbp->b_headp) goto done; /* EOL */ i = n; while (--i) { chunk += llength(nextp); nextp = lforw(nextp); if (nextp != curbp->b_headp) chunk++; /* newline */ if (nextp == curbp->b_headp) break; /* EOL */ } } else { /* n <= 0 */ chunk = curwp->w_doto; curwp->w_doto = 0; i = n; while (i++) { if (lforw(curwp->w_dotp)) chunk++; curwp->w_dotp = lback(curwp->w_dotp); curwp->w_rflag |= WFMOVE; chunk += llength(curwp->w_dotp); } } /* * KFORW here is a bug. Should be KBACK/KFORW, but we need to * rewrite the ldelete code (later)? */ done: if (chunk) return (ldelete(chunk, KFORW)); return (TRUE); } /* * Yank text back from the kill buffer. This is really easy. All of the work * is done by the standard insert routines. All you do is run the loop, and * check for errors. The blank lines are inserted with a call to "newline" * instead of a call to "lnewline" so that the magic stuff that happens when * you type a carriage return also happens when a carriage return is yanked * back from the kill buffer. An attempt has been made to fix the cosmetic * bug associated with a yank when dot is on the top line of the window * (nothing moves, because all of the new text landed off screen). */ /* ARGSUSED */ int yank(int f, int n) { struct line *lp; int c, i, nline; if (n < 0) return (FALSE); /* newline counting */ nline = 0; undo_boundary_enable(FFRAND, 0); while (n--) { /* mark around last yank */ isetmark(); i = 0; while ((c = kremove(i)) >= 0) { if (c == '\n') { if (enewline(FFRAND, 1) == FALSE) return (FALSE); ++nline; } else { if (linsert(1, c) == FALSE) return (FALSE); } ++i; } } /* cosmetic adjustment */ lp = curwp->w_linep; /* if offscreen insert */ if (curwp->w_dotp == lp) { while (nline-- && lback(lp) != curbp->b_headp) lp = lback(lp); /* adjust framing */ curwp->w_linep = lp; curwp->w_rflag |= WFFULL; } undo_boundary_enable(FFRAND, 1); return (TRUE); } mg-20161005/chrdef.h010064400017510001751000000034731276204442100126460ustar00hanboetes/* $OpenBSD: chrdef.h,v 1.10 2015/03/25 12:29:03 bcallah Exp $ */ /* This file is in the public domain. */ /* * sys/default/chardef.h: character set specific #defines for Mg 2a * Warning: System specific ones exist */ /* * Casting should be at least as efficient as anding with 0xff, * and won't have the size problems. */ #define CHARMASK(c) ((unsigned char) (c)) /* * These flags, and the macros below them, * make up a do-it-yourself set of "ctype" macros that * understand the DEC multinational set, and let me ask * a slightly different set of questions. */ #define _MG_W 0x01 /* Word. */ #define _MG_U 0x02 /* Upper case letter. */ #define _MG_L 0x04 /* Lower case letter. */ #define _MG_C 0x08 /* Control. */ #define _MG_P 0x10 /* end of sentence punctuation */ #define _MG_D 0x20 /* is decimal digit */ #define ISWORD(c) ((cinfo[CHARMASK(c)]&_MG_W)!=0) #define ISCTRL(c) ((cinfo[CHARMASK(c)]&_MG_C)!=0) #define ISUPPER(c) ((cinfo[CHARMASK(c)]&_MG_U)!=0) #define ISLOWER(c) ((cinfo[CHARMASK(c)]&_MG_L)!=0) #define ISEOSP(c) ((cinfo[CHARMASK(c)]&_MG_P)!=0) #define ISDIGIT(c) ((cinfo[CHARMASK(c)]&_MG_D)!=0) #define TOUPPER(c) ((c)-0x20) #define TOLOWER(c) ((c)+0x20) /* * Generally useful thing for chars */ #define CCHR(x) ((x) ^ 0x40) /* CCHR('?') == DEL */ #define K00 256 #define K01 257 #define K02 258 #define K03 259 #define K04 260 #define K05 261 #define K06 262 #define K07 263 #define K08 264 #define K09 265 #define K0A 266 #define K0B 267 #define K0C 268 #define K0D 269 #define K0E 270 #define K0F 271 #define K10 272 #define K11 273 #define K12 274 #define K13 275 #define K14 276 #define K15 277 #define K16 278 #define K17 279 #define K18 280 #define K19 281 #define K1A 282 #define K1B 283 #define K1C 284 #define K1D 285 #define K1E 286 #define K1F 287 mg-20161005/def.h010064400017510001751000000512611276204466300121570ustar00hanboetes/* $OpenBSD: def.h,v 1.155 2016/04/14 17:05:32 lum Exp $ */ /* This file is in the public domain. */ /* * This file is the general header file for all parts * of the Mg display editor. It contains all of the * general definitions and macros. It also contains some * conditional compilation flags. All of the per-system and * per-terminal definitions are in special header files. */ #include #include #include "chrdef.h" #if defined(__APPLE__) || defined(__FreeBSD__) # define LOGIN_NAME_MAX _POSIX_LOGIN_NAME_MAX #endif typedef int (*PF)(int, int); /* generally useful type */ /* * Table sizes, etc. */ #define NFILEN 1024 /* Length, file name. */ #define NBUFN NFILEN /* Length, buffer name. */ #define NLINE 256 /* Length, line. */ #define PBMODES 4 /* modes per buffer */ #define NPAT 80 /* Length, pattern. */ #define HUGE 1000 /* A rather large number. */ #define NSRCH 128 /* Undoable search commands. */ #define NXNAME 64 /* Length, extended command. */ #define NKNAME 20 /* Length, key names. */ #define NTIME 50 /* Length, timestamp string. */ /* * Universal. */ #define FALSE 0 /* False, no, bad, etc. */ #define TRUE 1 /* True, yes, good, etc. */ #define ABORT 2 /* Death, ^G, abort, etc. */ #define UERROR 3 /* User Error. */ #define REVERT 4 /* Revert the buffer */ #define KCLEAR 2 /* clear echo area */ /* * These flag bits keep track of * some aspects of the last command. The CFCPCN * flag controls goal column setting. The CFKILL * flag controls the clearing versus appending * of data in the kill buffer. */ #define CFCPCN 0x0001 /* Last command was C-P, C-N */ #define CFKILL 0x0002 /* Last command was a kill */ #define CFINS 0x0004 /* Last command was self-insert */ /* * File I/O. */ #define FIOSUC 0 /* Success. */ #define FIOFNF 1 /* File not found. */ #define FIOEOF 2 /* End of file. */ #define FIOERR 3 /* Error. */ #define FIOLONG 4 /* long line partially read */ #define FIODIR 5 /* File is a directory */ /* * Display colors. */ #define CNONE 0 /* Unknown color. */ #define CTEXT 1 /* Text color. */ #define CMODE 2 /* Mode line color. */ /* * Flags for keyboard invoked functions. */ #define FFUNIV 1 /* universal argument */ #define FFNEGARG 2 /* negative only argument */ #define FFOTHARG 4 /* other argument */ #define FFARG 7 /* any argument */ #define FFRAND 8 /* Called by other function */ /* * Flags for "eread". */ #define EFFUNC 0x0001 /* Autocomplete functions. */ #define EFBUF 0x0002 /* Autocomplete buffers. */ #define EFFILE 0x0004 /* " files (maybe someday) */ #define EFAUTO 0x0007 /* Some autocompletion on */ #define EFNEW 0x0008 /* New prompt. */ #define EFCR 0x0010 /* Echo CR at end; last read. */ #define EFDEF 0x0020 /* buffer contains default args */ #define EFNUL 0x0040 /* Null Minibuffer OK */ /* * Direction of insert into kill ring */ #define KNONE 0x00 #define KFORW 0x01 /* forward insert into kill ring */ #define KBACK 0x02 /* Backwards insert into kill ring */ #define KREG 0x04 /* This is a region-based kill */ #define MAX_TOKEN 64 /* * Previously from sysdef.h */ typedef int RSIZE; /* Type for file/region sizes */ typedef short KCHAR; /* Type for internal keystrokes */ /* * This structure holds the starting position * (as a line/offset pair) and the number of characters in a * region of a buffer. This makes passing the specification * of a region around a little bit easier. */ struct region { struct line *r_linep; /* Origin line address. */ int r_offset; /* Origin line offset. */ int r_lineno; /* Origin line number */ RSIZE r_size; /* Length in characters. */ }; /* * All text is kept in circularly linked * lists of "line" structures. These begin at the * header line (which is the blank line beyond the * end of the buffer). This line is pointed to by * the "buffer" structure. Each line contains the number of * bytes in the line (the "used" size), the size * of the text array, and the text. The end of line * is not stored as a byte; it's implied. Future * additions will include update hints, and a * list of marks into the line. */ struct line { struct line *l_fp; /* Link to the next line */ struct line *l_bp; /* Link to the previous line */ int l_size; /* Allocated size */ int l_used; /* Used size */ char *l_text; /* Content of the line */ }; /* * The rationale behind these macros is that you * could (with some editing, like changing the type of a line * link from a "struct line *" to a "REFLINE", and fixing the commands * like file reading that break the rules) change the actual * storage representation of lines to use something fancy on * machines with small address spaces. */ #define lforw(lp) ((lp)->l_fp) #define lback(lp) ((lp)->l_bp) #define lgetc(lp, n) (CHARMASK((lp)->l_text[(n)])) #define lputc(lp, n, c) ((lp)->l_text[(n)]=(c)) #define llength(lp) ((lp)->l_used) #define ltext(lp) ((lp)->l_text) /* * All repeated structures are kept as linked lists of structures. * All of these start with a LIST structure (except lines, which * have their own abstraction). This will allow for * later conversion to generic list manipulation routines should * I decide to do that. It does mean that there are four extra * bytes per window. I feel that this is an acceptable price, * considering that there are usually only one or two windows. */ struct list { union { struct mgwin *l_wp; struct buffer *x_bp; /* l_bp is used by struct line */ struct list *l_nxt; } l_p; char *l_name; }; /* * Usual hack - to keep from uglifying the code with lotsa * references through the union, we #define something for it. */ #define l_next l_p.l_nxt /* * There is a window structure allocated for * every active display window. The windows are kept in a * big list, in top to bottom screen order, with the listhead at * "wheadp". Each window contains its own values of dot and mark. * The flag field contains some bits that are set by commands * to guide redisplay; although this is a bit of a compromise in * terms of decoupling, the full blown redisplay is just too * expensive to run for every input character. */ struct mgwin { struct list w_list; /* List header */ struct buffer *w_bufp; /* Buffer displayed in window */ struct line *w_linep; /* Top line in the window */ struct line *w_dotp; /* Line containing "." */ struct line *w_markp; /* Line containing "mark" */ int w_doto; /* Byte offset for "." */ int w_marko; /* Byte offset for "mark" */ int w_toprow; /* Origin 0 top row of window */ int w_ntrows; /* # of rows of text in window */ int w_frame; /* #lines to reframe by. */ char w_rflag; /* Redisplay Flags. */ char w_flag; /* Flags. */ struct line *w_wrapline; int w_dotline; /* current line number of dot */ int w_markline; /* current line number of mark */ }; #define w_wndp w_list.l_p.l_wp #define w_name w_list.l_name /* * Window redisplay flags are set by command processors to * tell the display system what has happened to the buffer * mapped by the window. Setting "WFFULL" is always a safe thing * to do, but it may do more work than is necessary. Always try * to set the simplest action that achieves the required update. * Because commands set bits in the "w_flag", update will see * all change flags, and do the most general one. */ #define WFFRAME 0x01 /* Force reframe. */ #define WFMOVE 0x02 /* Movement from line to line. */ #define WFEDIT 0x04 /* Editing within a line. */ #define WFFULL 0x08 /* Do a full display. */ #define WFMODE 0x10 /* Update mode line. */ /* * Window flags */ #define WNONE 0x00 /* No special window options. */ #define WEPHEM 0x01 /* Window is ephemeral. */ struct undo_rec; TAILQ_HEAD(undoq, undo_rec); /* * Previously from sysdef.h * Only used in struct buffer. */ struct fileinfo { uid_t fi_uid; gid_t fi_gid; mode_t fi_mode; struct timespec fi_mtime; /* Last modified time */ }; /* * Text is kept in buffers. A buffer header, described * below, exists for every buffer in the system. The buffers are * kept in a big list, so that commands that search for a buffer by * name can find the buffer header. There is a safe store for the * dot and mark in the header, but this is only valid if the buffer * is not being displayed (that is, if "b_nwnd" is 0). The text for * the buffer is kept in a circularly linked list of lines, with * a pointer to the header line in "b_headp". */ struct buffer { struct list b_list; /* buffer list pointer */ struct buffer *b_altb; /* Link to alternate buffer */ struct line *b_dotp; /* Link to "." line structure */ struct line *b_markp; /* ditto for mark */ struct line *b_headp; /* Link to the header line */ struct maps_s *b_modes[PBMODES]; /* buffer modes */ int b_doto; /* Offset of "." in above line */ int b_marko; /* ditto for the "mark" */ short b_nmodes; /* number of non-fundamental modes */ char b_nwnd; /* Count of windows on buffer */ char b_flag; /* Flags */ char b_fname[NFILEN]; /* File name */ char b_cwd[NFILEN]; /* working directory */ struct fileinfo b_fi; /* File attributes */ struct undoq b_undo; /* Undo actions list */ struct undo_rec *b_undoptr; int b_dotline; /* Line number of dot */ int b_markline; /* Line number of mark */ int b_lines; /* Number of lines in file */ }; #define b_bufp b_list.l_p.x_bp #define b_bname b_list.l_name /* Some helper macros, in case they ever change to functions */ #define bfirstlp(buf) (lforw((buf)->b_headp)) #define blastlp(buf) (lback((buf)->b_headp)) #define BFCHG 0x01 /* Changed. */ #define BFBAK 0x02 /* Need to make a backup. */ #ifdef NOTAB #define BFNOTAB 0x04 /* no tab mode */ #endif #define BFOVERWRITE 0x08 /* overwrite mode */ #define BFREADONLY 0x10 /* read only mode */ #define BFDIRTY 0x20 /* Buffer was modified elsewhere */ #define BFIGNDIRTY 0x40 /* Ignore modifications */ #define BFDIREDDEL 0x80 /* Dired has a deleted 'D' file */ /* * This structure holds information about recent actions for the Undo command. */ struct undo_rec { TAILQ_ENTRY(undo_rec) next; enum { INSERT = 1, DELETE, BOUNDARY, MODIFIED, DELREG } type; struct region region; int pos; char *content; }; /* * Previously from ttydef.h */ #define STANDOUT_GLITCH /* possible standout glitch */ #define putpad(str, num) tputs(str, num, ttputc) #define KFIRST K00 #define KLAST K00 /* * Prototypes. */ /* tty.c X */ void ttinit(void); void ttreinit(void); void tttidy(void); void ttmove(int, int); void tteeol(void); void tteeop(void); void ttbeep(void); void ttinsl(int, int, int); void ttdell(int, int, int); void ttwindow(int, int); void ttnowindow(void); void ttcolor(int); void ttresize(void); volatile sig_atomic_t winch_flag; /* ttyio.c */ void ttopen(void); int ttraw(void); void ttclose(void); int ttcooked(void); int ttputc(int); void ttflush(void); int ttgetc(void); int ttwait(int); int charswaiting(void); /* dir.c */ void dirinit(void); int changedir(int, int); int showcwdir(int, int); int getcwdir(char *, size_t); int makedir(int, int); int do_makedir(char *); int ask_makedir(void); /* dired.c */ struct buffer *dired_(char *); int do_dired(char *); /* file.c X */ int fileinsert(int, int); int filevisit(int, int); int filevisitalt(int, int); int filevisitro(int, int); int poptofile(int, int); int readin(char *); int insertfile(char *, char *, int); int filewrite(int, int); int filesave(int, int); int buffsave(struct buffer *); int makebkfile(int, int); int writeout(FILE **, struct buffer *, char *); void upmodes(struct buffer *); size_t xbasename(char *, const char *, size_t); int do_filevisitalt(char *); /* line.c X */ struct line *lalloc(int); int lrealloc(struct line *, int); void lfree(struct line *); void lchange(int); int linsert(int, int); int lnewline_at(struct line *, int); int lnewline(void); int ldelete(RSIZE, int); int ldelnewline(void); int lreplace(RSIZE, char *); char * linetostr(const struct line *); /* yank.c X */ void kdelete(void); int kinsert(int, int); int kremove(int); int kchunk(char *, RSIZE, int); int killline(int, int); int yank(int, int); /* window.c X */ struct mgwin *new_window(struct buffer *); int reposition(int, int); int redraw(int, int); int do_redraw(int, int, int); int nextwind(int, int); int prevwind(int, int); int onlywind(int, int); int splitwind(int, int); int enlargewind(int, int); int shrinkwind(int, int); int delwind(int, int); /* buffer.c */ int togglereadonly(int, int); struct buffer *bfind(const char *, int); int poptobuffer(int, int); int killbuffer(struct buffer *); int killbuffer_cmd(int, int); int savebuffers(int, int); int listbuffers(int, int); int addlinef(struct buffer *, char *, ...); #define addline(bp, text) addlinef(bp, "%s", text) int anycb(int); int bclear(struct buffer *); int showbuffer(struct buffer *, struct mgwin *, int); int augbname(char *, const char *, size_t); struct mgwin *popbuf(struct buffer *, int); int bufferinsert(int, int); int usebuffer(int, int); int notmodified(int, int); int popbuftop(struct buffer *, int); int getbufcwd(char *, size_t); int checkdirty(struct buffer *); int revertbuffer(int, int); int dorevert(void); int diffbuffer(int, int); struct buffer *findbuffer(char *); /* display.c */ int vtresize(int, int, int); void vtinit(void); void vttidy(void); void update(int); int linenotoggle(int, int); int colnotoggle(int, int); /* echo.c X */ void eerase(void); int eyorn(const char *); int eynorr(const char *); int eyesno(const char *); void ewprintf(const char *fmt, ...); char *eread(const char *, char *, size_t, int, ...) __attribute__((__format__ (printf, 1, 5))); int getxtra(struct list *, struct list *, int, int); void free_file_list(struct list *); /* fileio.c */ int ffropen(FILE **, const char *, struct buffer *); void ffstat(FILE *, struct buffer *); int ffwopen(FILE **, const char *, struct buffer *); int ffclose(FILE *, struct buffer *); int ffputbuf(FILE *, struct buffer *); int ffgetline(FILE *, char *, int, int *); int fbackupfile(const char *); char *adjustname(const char *, int); char *startupfile(char *); int copy(char *, char *); struct list *make_file_list(char *); int fisdir(const char *); int fchecktime(struct buffer *); int fupdstat(struct buffer *); int backuptohomedir(int, int); int toggleleavetmp(int, int); char *expandtilde(const char *); /* kbd.c X */ int do_meta(int, int); int bsmap(int, int); void ungetkey(int); int getkey(int); int doin(void); int rescan(int, int); int universal_argument(int, int); int digit_argument(int, int); int negative_argument(int, int); int selfinsert(int, int); int quote(int, int); /* main.c */ int ctrlg(int, int); int quit(int, int); /* ttyio.c */ void panic(char *); /* cinfo.c */ char *getkeyname(char *, size_t, int); /* basic.c */ int gotobol(int, int); int backchar(int, int); int gotoeol(int, int); int forwchar(int, int); int gotobob(int, int); int gotoeob(int, int); int forwline(int, int); int backline(int, int); void setgoal(void); int getgoal(struct line *); int forwpage(int, int); int backpage(int, int); int forw1page(int, int); int back1page(int, int); int pagenext(int, int); void isetmark(void); int setmark(int, int); int clearmark(int, int); int swapmark(int, int); int gotoline(int, int); int setlineno(int); /* random.c X */ int showcpos(int, int); int getcolpos(struct mgwin *); int twiddle(int, int); int openline(int, int); int enewline(int, int); int deblank(int, int); int justone(int, int); int delwhite(int, int); int delleadwhite(int, int); int deltrailwhite(int, int); int lfindent(int, int); int indent(int, int); int forwdel(int, int); int backdel(int, int); int space_to_tabstop(int, int); int backtoindent(int, int); int joinline(int, int); /* tags.c X */ int findtag(int, int); int poptag(int, int); int tagsvisit(int, int); int curtoken(int, int, char *); /* cscope.c */ int cssymbol(int, int); int csdefinition(int, int); int csfuncalled(int, int); int cscallerfuncs(int, int); int csfindtext(int, int); int csegrep(int, int); int csfindfile(int, int); int csfindinc(int, int); int csnextfile(int, int); int csnextmatch(int, int); int csprevfile(int, int); int csprevmatch(int, int); int cscreatelist(int, int); /* extend.c X */ int insert(int, int); int bindtokey(int, int); int localbind(int, int); int redefine_key(int, int); int unbindtokey(int, int); int localunbind(int, int); int extend(int, int); int evalexpr(int, int); int evalbuffer(int, int); int evalfile(int, int); int load(const char *); int excline(char *); /* help.c X */ int desckey(int, int); int wallchart(int, int); int help_help(int, int); int apropos_command(int, int); /* paragraph.c X */ int gotobop(int, int); int gotoeop(int, int); int fillpara(int, int); int killpara(int, int); int fillword(int, int); int setfillcol(int, int); int markpara(int, int); int transposepara(int, int); int sentencespace(int, int); /* word.c X */ int backword(int, int); int forwword(int, int); int upperword(int, int); int lowerword(int, int); int capword(int, int); int delfword(int, int); int delbword(int, int); int inword(void); int transposeword(int, int); /* region.c X */ int killregion(int, int); int copyregion(int, int); int lowerregion(int, int); int upperregion(int, int); int prefixregion(int, int); int setprefix(int, int); int region_get_data(struct region *, char *, int); void region_put_data(const char *, int); int markbuffer(int, int); int piperegion(int, int); int shellcommand(int, int); int pipeio(const char * const, char * const[], char * const, int, struct buffer *); /* search.c X */ int forwsearch(int, int); int backsearch(int, int); int searchagain(int, int); int forwisearch(int, int); int backisearch(int, int); int queryrepl(int, int); int forwsrch(void); int backsrch(void); int readpattern(char *); /* spawn.c X */ int spawncli(int, int); /* ttykbd.c X */ void ttykeymapinit(void); void ttykeymaptidy(void); /* match.c X */ int showmatch(int, int); /* version.c X */ int showversion(int, int); /* macro.c X */ int definemacro(int, int); int finishmacro(int, int); int executemacro(int, int); /* modes.c X */ int indentmode(int, int); int fillmode(int, int); #ifdef NOTAB int notabmode(int, int); #endif /* NOTAB */ int overwrite_mode(int, int); int set_default_mode(int,int); #ifdef REGEX /* re_search.c X */ int re_forwsearch(int, int); int re_backsearch(int, int); int re_searchagain(int, int); int re_queryrepl(int, int); int replstr(int, int); int setcasefold(int, int); int delmatchlines(int, int); int delnonmatchlines(int, int); int cntmatchlines(int, int); int cntnonmatchlines(int, int); #endif /* REGEX */ /* undo.c X */ void free_undo_record(struct undo_rec *); int undo_dump(int, int); int undo_enabled(void); int undo_enable(int, int); int undo_add_boundary(int, int); void undo_add_modified(void); int undo_add_insert(struct line *, int, int); int undo_add_delete(struct line *, int, int, int); int undo_boundary_enable(int, int); int undo_add_change(struct line *, int, int); int undo(int, int); /* autoexec.c X */ int auto_execute(int, int); PF *find_autoexec(const char *); int add_autoexec(const char *, const char *); /* cmode.c X */ int cmode(int, int); int cc_brace(int, int); int cc_char(int, int); int cc_tab(int, int); int cc_indent(int, int); int cc_lfindent(int, int); /* grep.c X */ int next_error(int, int); int globalwdtoggle(int, int); int compile(int, int); /* bell.c */ void bellinit(void); int toggleaudiblebell(int, int); int togglevisiblebell(int, int); void dobeep(void); /* * Externals. */ extern struct buffer *bheadp; extern struct buffer *curbp; extern struct mgwin *curwp; extern struct mgwin *wheadp; extern int thisflag; extern int lastflag; extern int curgoal; extern int startrow; extern int epresf; extern int sgarbf; extern int mode; extern int nrow; extern int ncol; extern int ttrow; extern int ttcol; extern int tttop; extern int ttbot; extern int tthue; extern int defb_nmodes; extern int defb_flag; extern int doaudiblebell; extern int dovisiblebell; extern int dblspace; extern char cinfo[]; extern char *keystrings[]; extern char pat[NPAT]; extern char prompt[]; /* * Globals. */ int tceeol; int tcinsl; int tcdell; int rptcount; /* successive invocation count */ mg-20161005/funmap.h010064400017510001751000000004331276204442100126720ustar00hanboetes/* $OpenBSD: funmap.h,v 1.7 2008/06/10 00:19:31 kjell Exp $ */ /* This file is in the public domain */ void funmap_init(void); PF name_function(const char *); const char *function_name(PF); struct list *complete_function_list(const char *); int funmap_add(PF, const char *); mg-20161005/kbd.h010064400017510001751000000031221276204442100121420ustar00hanboetes/* $OpenBSD: kbd.h,v 1.19 2015/03/19 21:48:05 bcallah Exp $ */ /* This file is in the public domain. */ /* * kbd.h: type definitions for symbol.c and kbd.c for mg experimental */ struct map_element { KCHAR k_base; /* first key in element */ KCHAR k_num; /* last key in element */ PF *k_funcp; /* pointer to array of pointers */ /* to functions */ struct keymap_s *k_prefmap; /* keymap of ONLY prefix key in */ /* element */ }; /* * Predefined keymaps are NOT type KEYMAP because final array needs * dimension. If any changes are made to this struct, they must be reflected * in all keymap declarations. */ #define KEYMAPE(NUM) { \ short map_num; /* elements used */ \ short map_max; /* elements allocated */\ PF map_default; /* default function */ \ struct map_element map_element[NUM]; /* really [e_max] */ \ } typedef struct keymap_s KEYMAPE(1) KEYMAP; /* Number of map_elements to grow an overflowed keymap by */ #define MAPGROW 3 #define MAPINIT (MAPGROW+1) /* Max number of default bindings added to avoid creating new element */ #define MAPELEDEF 4 struct maps_s { KEYMAP *p_map; const char *p_name; struct maps_s *p_next; }; extern struct maps_s *maps; extern struct maps_s fundamental_mode; #define fundamental_map (fundamental_mode.p_map) int dobindkey(KEYMAP *, const char *, const char *); KEYMAP *name_map(const char *); struct maps_s *name_mode(const char *); PF doscan(KEYMAP *, int, KEYMAP **); void maps_init(void); int maps_add(KEYMAP *, const char *); extern struct map_element *ele; extern struct maps_s *defb_modes[]; mg-20161005/key.h010064400017510001751000000006101276204442100121710ustar00hanboetes/* $OpenBSD: key.h,v 1.5 2005/06/14 18:14:40 kjell Exp $ */ /* This file is in the public domain. */ /* key.h: Insert file for mg 2 functions that need to reference key pressed */ #define MAXKEY 8 /* maximum number of prefix chars */ struct key { /* the chacter sequence in a key */ int k_count; /* number of chars */ KCHAR k_chars[MAXKEY]; /* chars */ }; extern struct key key; mg-20161005/macro.h010064400017510001751000000006651276204442100125140ustar00hanboetes/* $OpenBSD: macro.h,v 1.7 2005/11/18 20:56:53 deraadt Exp $ */ /* This file is in the public domain. */ /* definitions for keyboard macros */ #define MAXMACRO 256 /* maximum functs in a macro */ extern int inmacro; extern int macrodef; extern int macrocount; union macrodef { PF m_funct; int m_count; /* for count-prefix */ }; extern union macrodef macro[MAXMACRO]; extern struct line *maclhead; extern struct line *maclcur; mg-20161005/pathnames.h010064400017510001751000000003621276204442100133650ustar00hanboetes/* $OpenBSD: pathnames.h,v 1.1 2012/06/18 07:14:55 jasper Exp $ */ /* This file is in the public domain. */ /* * standard path names */ #define _PATH_MG_DIR "~/.mg.d" #define _PATH_MG_STARTUP "%s/.mg" #define _PATH_MG_TERM "%s/.mg-%s" mg-20161005/mg.1010064400017510001751000000727001276204466300117360ustar00hanboetes.\" $OpenBSD: mg.1,v 1.105 2016/07/28 21:37:45 tedu Exp $ .\" This file is in the public domain. .\" .Dd $Mdocdate: July 28 2016 $ .Dt MG 1 .Os .Sh NAME .Nm mg .Nd emacs-like text editor .Sh SYNOPSIS .Nm mg .Op Fl nR .Op Fl f Ar mode .Op + Ns Ar number .Op Ar .Sh DESCRIPTION .Nm is intended to be a small, fast, and portable editor for people who can't (or don't want to) run emacs for one reason or another, or are not familiar with the .Xr vi 1 editor. It is compatible with emacs because there shouldn't be any reason to learn more editor types than emacs or .Xr vi 1 . .Pp The options are as follows: .Bl -tag -width Ds .It + Ns Ar number Go to the line specified by number (do not insert a space between the .Sq + sign and the number). If a negative number is specified, the line number counts backwards from the end of the file i.e. +-1 will be the last line of the file, +-2 will be second last, and so on. .It Fl f Ar mode Run the mode command for all buffers created from arguments on the command line, including the scratch buffer and all files. .It Fl n Turn off backup file generation. .It Fl R Files specified on the command line will be opened read-only. .El .Sh WINDOWS AND BUFFERS When a file is loaded into .Nm , it is stored in a .Em buffer . This buffer may be displayed on the screen in more than one window. At present, windows may only be split horizontally, so each window is delineated by a modeline at the bottom. If changes are made to a buffer, it will be reflected in all open windows. .Pp If a file is changed outside .Nm and its buffer is about to be changed, .Nm prompts if the change should go ahead (y), not go ahead (n) or if the buffer should be reverted (r) to the latest file on disk. .Pp If a buffer name begins and ends with an asterisk, the buffer is considered throwaway; i.e. the user will not be prompted to save changes when the buffer is killed. .Sh POINT AND MARK The current cursor location in .Nm is called the .Em point (or .Em dot ) . It is possible to define a window-specific region of text by setting a second location, called the .Em mark . The .Em region is the text between point and mark inclusive. Deleting the character at the mark position leaves the mark at the point of deletion. .Pp Note: The point and mark are window-specific in .Nm , not buffer-specific, as in other emacs flavours. .Sh BACKUP FILES Backup files have a .Sq ~ character appended to the file name and are created in the current working directory by default. Whether to create backup files or not can be toggled with the make-backup-files command. The backup file location can either be in the current working directory, or all backups can be moved to a .Pa ~/.mg.d directory where files retain their path name to retain uniqueness. Use the backup-to-home-directory to alternate between these two locations. Further, if any application creates backup files in .Pa /tmp , these can be left with the leave-tmpdir-backups command. .Sh TAGS .Nm supports tag files created by .Xr ctags 1 , allowing the user to quickly locate various object definitions. Note though that emacs uses etags, not ctags. .Sh CSCOPE .Nm supports navigating source code using cscope. However, .Nm requires cscope and cscope-indexer executables to be present in .Ev PATH for it to work. .Sh DEFAULT KEY BINDINGS Normal editing commands are very similar to GNU Emacs. In the following examples, C-x means Control-x, and M-x means Meta-x, where the Meta key may be either a special key on the keyboard or the ALT key; otherwise ESC followed by the key X works as well. .Pp .Bl -tag -width xxxxxxxxxxxx -offset indent -compact .It C-SPC set-mark-command .It C-a beginning-of-line .It C-b backward-char .It C-c s c cscope-find-functions-calling-this-function .It C-c s d cscope-find-global-definition .It C-c s e cscope-find-egrep-pattern .It C-c s f cscope-find-this-file .It C-c s i cscope-find-files-including-file .It C-c s n cscope-next-symbol .It C-c s p cscope-prev-symbol .It C-c s s cscope-find-this-symbol .It C-c s t cscope-find-this-text-string .It C-d delete-char .It C-e end-of-line .It C-f forward-char .It C-g keyboard-quit .It C-h C-h help-help .It C-h a apropos .It C-h b describe-bindings .It C-h c describe-key-briefly .It C-j newline-and-indent .It C-k kill-line .It C-l recenter .It RET newline .It C-n next-line .It C-o open-line .It C-p previous-line .It C-q quoted-insert .It C-r isearch-backward .It C-s isearch-forward .It C-t transpose-chars .It C-u universal-argument .It C-v scroll-up .It C-w kill-region .It C-x C-b list-buffers .It C-x C-c save-buffers-kill-emacs .It C-x C-f find-file .It C-x C-g keyboard-quit .It C-x C-l downcase-region .It C-x C-o delete-blank-lines .It C-x C-q toggle-read-only .It C-x C-r find-file-read-only .It C-x C-s save-buffer .It C-x C-u upcase-region .It C-x C-v find-alternate-file .It C-x C-w write-file .It C-x C-x exchange-point-and-mark .It C-x ( start-kbd-macro .It C-x \&) end-kbd-macro .It C-x 0 delete-window .It C-x 1 delete-other-windows .It C-x 2 split-window-vertically .It C-x 4 C-f find-file-other-window .It C-x 4 C-g keyboard-quit .It C-x 4 b switch-to-buffer-other-window .It C-x 4 f find-file-other-window .It C-x = what-cursor-position .It C-x ^ enlarge-window .It C-x ` next-error .It C-x b switch-to-buffer .It C-x d dired .It C-x e call-last-kbd-macro .It C-x f set-fill-column .It C-x g goto-line .It C-x h mark-whole-buffer .It C-x i insert-file .It C-x k kill-buffer .It C-x n other-window .It C-x o other-window .It C-x p previous-window .It C-x s save-some-buffers .It C-x u undo .It C-y yank .It C-z suspend-emacs .It M-C-v scroll-other-window .It M-SPC just-one-space .It M-! shell-command .It M-. find-tag .It M-* pop-tag-mark .It M-% query-replace .It M-< beginning-of-buffer .It M-> end-of-buffer .It M-\e delete-horizontal-space .It M-^ join-line .It M-b backward-word .It M-c capitalize-word .It M-d kill-word .It M-f forward-word .It M-h mark-paragraph .It M-l downcase-word .It M-m back-to-indentation .It M-q fill-paragraph .It M-r search-backward .It M-s search-forward .It M-t transpose-words .It M-u upcase-word .It M-v scroll-down .It M-w copy-region-as-kill .It M-x execute-extended-command .It M-{ backward-paragraph .It M-| shell-command-on-region .It M-} forward-paragraph .It M-~ not-modified .It M-DEL backward-kill-word .It C-_ undo .It ) blink-and-insert .It DEL delete-backward-char .El .Pp For a complete description of .Nm commands, see .Sx MG COMMANDS . To see the active keybindings at any time, type .Dq M-x describe-bindings . .Sh MG COMMANDS Commands are invoked by .Dq M-x , or by binding to a key. Many commands take an optional numerical parameter, .Va n . This parameter is set either by M- (where .Va n is the numerical argument) before the command, or by one or more invocations of the universal argument, usually bound to C-u. When invoked in this manner, the value of the numeric parameter to be passed is displayed in the minibuffer before the M-x. One common use of the parameter is in mode toggles (e.g.\& make-backup-files). If no parameter is supplied, the mode is toggled to its alternate state. If a positive parameter is supplied, the mode is forced to on. Otherwise, it is forced to off. .\" .Bl -tag -width xxxxx .It apropos Help Apropos. Prompt the user for a string, open the *help* buffer, and list all .Nm commands that contain that string. .It audible-bell Toggle the audible system bell. .It auto-execute Register an auto-execute hook; that is, specify a filename pattern (conforming to the shell's filename globbing rules) and an associated function to execute when a file matching the specified pattern is read into a buffer. .It auto-fill-mode Toggle auto-fill mode (sometimes called mail-mode) in the current buffer, where text inserted past the fill column is automatically wrapped to a new line. Can be set globally with set-default-mode. .It auto-indent-mode Toggle indent mode in the current buffer, where indentation is preserved after a newline. Can be set globally with set-default-mode. .It back-to-indentation Move the dot to the first non-whitespace character on the current line. .It backup-to-home-directory Save backup copies to a .Pa ~/.mg.d directory instead of working directory. Requires make-backup-files to be on. .It backward-char Move cursor backwards one character. .It backward-kill-word Kill text backwards by .Va n words. .It backward-paragraph Move cursor backwards .Va n paragraphs. Paragraphs are delimited by or or . .It backward-word Move cursor backwards by the specified number of words. .It beginning-of-buffer Move cursor to the top of the buffer. .It beginning-of-line Move cursor to the beginning of the line. .It blink-and-insert Self-insert a character, then search backwards and blink its matching delimiter. For delimiters other than parenthesis, brackets, and braces, the character itself is used as its own match. .It bsmap-mode Toggle bsmap mode, where DEL and C-h are swapped. .It c-mode Toggle a KNF-compliant mode for editing C program files. .It call-last-kbd-macro Invoke the keyboard macro. .It capitalize-word Capitalize .Va n words; i.e. convert the first character of the word to upper case, and subsequent letters to lower case. .It cd Change the global working directory. See also global-wd-mode. .It column-number-mode Toggle whether the column number is displayed in the modeline. .It copy-region-as-kill Copy all of the characters in the region to the kill buffer, clearing the mark afterwards. This is a bit like a kill-region followed by a yank. .It count-matches Count the number of lines matching the supplied regular expression. .It count-non-matches Count the number of lines not matching the supplied regular expression. .It cscope-find-this-symbol List the matches for the given symbol. .It cscope-find-global-definition List global definitions for the given literal. .It cscope-find-called-functions List functions called from the given function. .It cscope-find-functions-calling-this-function List functions calling the given function. .It cscope-find-this-text-string List locations matching the given text string. .It cscope-find-egrep-pattern List locations matching the given extended regular expression pattern. .It cscope-find-this-file List filenames matching the given filename. .It cscope-find-files-including-file List files that #include the given filename. .It cscope-next-symbol Navigate to the next match. .It cscope-prev-symbol Navigate to the previous match. .It cscope-next-file Navigate to the next file. .It cscope-prev-file Navigate to the previous file. .It cscope-create-list-of-files-to-index Create cscope's List and Index in the given directory. .It define-key Prompts the user for a named keymap (mode), a key, and an .Nm command, then creates a keybinding in the appropriate map. .It delete-backward-char Delete backwards .Va n characters. Like delete-char, this actually does a kill if presented with an argument. .It delete-blank-lines Delete blank lines around dot. If dot is sitting on a blank line, this command deletes all the blank lines above and below the current line. Otherwise, it deletes all of the blank lines after the current line. .It delete-char Delete .Va n characters forward. If any argument is present, it kills rather than deletes, saving the result in the kill buffer. .It delete-horizontal-space Delete any whitespace around the dot. .It delete-leading-space Delete leading whitespace on the current line. .It delete-trailing-space Delete trailing whitespace on the current line. .It delete-matching-lines Delete all lines after dot that contain a string matching the supplied regular expression. .It delete-non-matching-lines Delete all lines after dot that contain a string matching the supplied regular expression. .It delete-other-windows Make the current window the only window visible on the screen. .It delete-window Delete current window. .It describe-bindings List all global and local keybindings, putting the result in the *help* buffer. .It describe-key-briefly Read a key from the keyboard, and look it up in the keymap. Display the name of the function currently bound to the key. .It diff-buffer-with-file View the differences between buffer and its associated file. .It digit-argument Process a numerical argument for keyboard-invoked functions. .It downcase-region Set all characters in the region to lower case. .It downcase-word Set characters to lower case, starting at the dot, and ending .Va n words away. .It emacs-version Return an .Nm version string. .It end-kbd-macro Stop defining a keyboard macro. .It end-of-buffer Move cursor to the end of the buffer. .It end-of-line Move cursor to the end of the line. .It enlarge-window Enlarge the current window by shrinking either the window above or below it. .It eval-current-buffer Evaluate the current buffer as a series of .Nm commands. Useful for testing .Nm startup files. .It eval-expression Get one line from the user, and run it. Useful for testing expressions in .Nm startup files. .It exchange-point-and-mark Swap the values of "dot" and "mark" in the current window. Return an error if no mark is set. .It execute-extended-command Invoke an extended command; i.e. M-x. Call the message line routine to read in the command name and apply autocompletion to it. When it comes back, look the name up in the symbol table and run the command if it is found, passing arguments as necessary. Print an error if there is anything wrong. .It fill-paragraph Justify a paragraph, wrapping text at the current fill column. .It find-file Select a file for editing. First check if the file can be found in another buffer; if it is there, just switch to that buffer. If the file cannot be found, create a new buffer, read in the file from disk, and switch to the new buffer. .It find-file-read-only Same as find-file, except the new buffer is set to read-only. .It find-alternate-file Replace the current file with an alternate one. Semantics for finding the replacement file are the same as find-file, except the current buffer is killed before the switch. If the kill fails, or is aborted, revert to the original file. .It find-file-other-window Opens the specified file in a second buffer. Splits the current window if necessary. .It find-tag Jump to definition of tag at dot. .It forward-char Move cursor forwards (or backwards, if .Va n is negative) .Va n characters. Returns an error if the end of buffer is reached. .It forward-paragraph Move forward .Va n paragraphs. Paragraphs are delimited by or or . .It forward-word Move the cursor forward by the specified number of words. .It global-set-key Bind a key in the global (fundamental) key map. .It global-unset-key Unbind a key from the global (fundamental) key map; i.e. set it to 'rescan'. .It global-wd-mode Toggle global working-directory mode. When enabled, .Nm defaults to opening files (and executing commands like compile and grep) relative to the global working directory. When disabled, a working directory is set for each buffer. .It goto-line Go to a specific line. If an argument is present, then it is the line number, else prompt for a line number to use. .It help-help Prompts for one of (a)propos, (b)indings, des(c)ribe key briefly. .It insert Insert a string, mainly for use from macros. .It insert-buffer Insert the contents of another buffer at dot. .It insert-file Insert a file into the current buffer at dot. .It insert-with-wrap Insert the bound character with word wrap. Check to see if we're past the fill column, and if so, justify this line. .It isearch-backward Use incremental searching, initially in the reverse direction. isearch ignores any explicit arguments. If invoked during macro definition or evaluation, the non-incremental search-backward is invoked instead. .It isearch-forward Use incremental searching, initially in the forward direction. isearch ignores any explicit arguments. If invoked during macro definition or evaluation, the non-incremental search-forward is invoked instead. .It join-line Join the current line to the previous. If called with an argument, join the next line to the current one. .It just-one-space Delete any whitespace around dot, then insert a space. .It keyboard-quit Abort the current action. .It kill-buffer Dispose of a buffer, by name. If the buffer name does not start and end with an asterisk, prompt the user if the buffer has been changed. .It kill-line Kill line. If called without an argument, it kills from dot to the end of the line, unless it is at the end of the line, when it kills the newline. If called with an argument of 0, it kills from the start of the line to dot. If called with a positive argument, it kills from dot forward over that number of newlines. If called with a negative argument it kills any text before dot on the current line, then it kills back abs(n) lines. .It kill-paragraph Delete .Va n paragraphs starting with the current one. .It kill-region Kill the currently defined region. .It kill-word Delete forward .Va n words. .It leave-tmpdir-backups Modifies the behaviour of backup-to-home-directory. Backup files that would normally reside in .Pa /tmp are left there and not moved to the .Pa ~/.mg.d directory. .It line-number-mode Toggle whether the line number is displayed in the modeline. .It list-buffers Display the list of available buffers. .It load Prompt the user for a filename, and then execute commands from that file. .It local-set-key Bind a key mapping in the local (topmost) mode. .It local-unset-key Unbind a key mapping in the local (topmost) mode. .It make-backup-files Toggle generation of backup files. .It make-directory Prompt the user for a path or directory name which is then created. .It mark-paragraph Mark .Va n paragraphs. .It mark-whole-buffer Marks whole buffer as a region by putting dot at the beginning and mark at the end of buffer. .It meta-key-mode When disabled, the meta key can be used to insert extended-ascii (8-bit) characters. When enabled, the meta key acts as usual. .It negative-argument Process a negative argument for keyboard-invoked functions. .It newline Insert a newline into the current buffer. .It newline-and-indent Insert a newline, then enough tabs and spaces to duplicate the indentation of the previous line. Assumes tabs are every eight characters. .It next-line Move forward .Va n lines. .\" .It no-tab-mode .\" Toggle notab mode. .\" In this mode, spaces are inserted rather than tabs. .It not-modified Turn off the modified flag in the current buffer. .It open-line Open up some blank space. Essentially, insert .Va n newlines, then back up over them. .It other-window The command to make the next (down the screen) window the current window. There are no real errors, although the command does nothing if there is only 1 window on the screen. .It overwrite-mode Toggle overwrite mode in the current buffer, where typing overwrites existing characters rather than inserting them. Can be set globally with set-default-mode. .It prefix-region Inserts a prefix string before each line of a region. The prefix string is settable by using 'set-prefix-string'. .It previous-line Move backwards .Va n lines. .It previous-window This command makes the previous (up the screen) window the current window. There are no errors, although the command does not do a lot if there is only 1 window. .It pop-tag-mark Return to position where find-tag was previously invoked. .It push-shell Suspend .Nm and switch to alternate screen, if available. .It pwd Display current (global) working directory in the status area. .It query-replace Query Replace. Search and replace strings selectively, prompting after each match. .It replace-string Replace string globally without individual prompting. .It query-replace-regexp Replace strings selectively. Does a search and replace operation using regular expressions for both patterns. .It quoted-insert Insert the next character verbatim into the current buffer; i.e. ignore any function bound to that key. .It re-search-again Perform a regular expression search again, using the same search string and direction as the last search command. .It re-search-backward Search backwards using a regular expression. Get a search string from the user, and search, starting at dot and proceeding toward the front of the buffer. If found, dot is left pointing at the first character of the pattern [the last character that was matched]. .It re-search-forward Search forward using a regular expression. Get a search string from the user and search for it starting at dot. If found, move dot to just after the matched characters. display does all the hard stuff. If not found, it just prints a message. .It recenter Reposition dot in the current window. By default, the dot is centered. If given a positive argument (n), the display is repositioned to line n. If .Va n is negative, it is that line from the bottom. .It redraw-display Refresh the display. Recomputes all window sizes in case something has changed. .It revert-buffer Revert the current buffer to the latest file on disk. .It save-buffer Save the contents of the current buffer if it has been changed, optionally creating a backup copy. .It save-buffers-kill-emacs Offer to save modified buffers and quit .Nm . .It save-some-buffers Look through the list of buffers, offering to save any buffer that has been changed. Buffers that are not associated with files (such as *scratch*, *grep*, *compile*) are ignored. .It scroll-down Scroll backwards .Va n pages. A two-line overlap between pages is assumed. If given a repeat argument, scrolls back lines, not pages. .It scroll-one-line-down Scroll the display down .Va n lines without changing the cursor position. .It scroll-one-line-up Scroll the display .Va n lines up without moving the cursor position. .It scroll-other-window Scroll the next window in the window list window forward .Va n pages. .It scroll-up Scroll forward one page. A two-line overlap between pages is assumed. If given a repeat argument, scrolls back lines, not pages. .It search-again Search again, using the same search string and direction as the last search command. .It search-backward Reverse search. Get a search string from the user, and search, starting at dot and proceeding toward the front of the buffer. If found, dot is left pointing at the first character of the pattern (the last character that was matched). .It search-forward Search forward. Get a search string from the user, and search for it starting at dot. If found, dot gets moved to just after the matched characters, if not found, print a message. .It self-insert-command Insert a character. .It sentence-end-double-space Toggle double or single spaces for end of sentences. Double is the default. Currently only affects fill-paragraph. .It set-case-fold-search Set case-fold searching, causing case not to matter in regular expression searches. This is the default. .It set-default-mode Append the supplied mode to the list of default modes used by subsequent buffer creation. Built in modes include: fill, indent and overwrite. .It set-fill-column Prompt the user for a fill column. Used by auto-fill-mode. .It set-mark-command Sets the mark in the current window to the current dot location. .It set-prefix-string Sets the prefix string to be used by the 'prefix-region' command. .It shell-command Execute external command from mini-buffer. .It shell-command-on-region Provide the text in region to the shell command as input. .It shrink-window Shrink current window by one line. The window immediately below is expanded to pick up the slack. If only one window is present, this command has no effect. .It split-window-vertically Split the current window. A window smaller than 3 lines cannot be split. .It start-kbd-macro Start defining a keyboard macro. Macro definition is ended by invoking end-kbd-macro. .It suspend-emacs Suspend .Nm and switch back to alternate screen, if in use. .It switch-to-buffer Prompt and switch to a new buffer in the current window. .It switch-to-buffer-other-window Switch to buffer in another window. .It toggle-read-only Toggle the read-only flag on the current buffer. .It transpose-chars Transpose the two characters in front of and under dot, then move forward one character. Treat newline characters the same as any other. .It transpose-paragraphs Transpose adjacent paragraphs. If multiple iterations are requested, the current paragraph will be moved .Va n paragraphs forward. .It transpose-words Transpose adjacent words. .It undo Undo the most recent action. If invoked again without an intervening command, move the undo pointer to the previous action and undo it. .It undo-boundary Add an undo boundary. This is not usually done interactively. .It undo-boundary-toggle Toggle whether undo boundaries are generated. Undo boundaries are often disabled before operations that should be considered atomically undoable. .It undo-enable Toggle whether undo information is kept. .It undo-list Show the undo records for the current buffer in a new buffer. .It universal-argument Repeat the next command 4 times. Usually bound to C-u. This command may be stacked; e.g.\& C-u C-u C-f moves the cursor forward 16 characters. .It upcase-region Upper case region. Change all of the lower case characters in the region to upper case. .It upcase-word Move the cursor forward by the specified number of words. As it moves, convert any characters to upper case. .It visible-bell Toggle the visible bell. If this toggle is on, the modeline will flash. .It visit-tags-table Record name of the tags file to be used for subsequent find-tag. .It what-cursor-position Display a bunch of useful information about the current location of dot. The character under the cursor (in octal), the current line, row, and column, and approximate position of the cursor in the file (as a percentage) is displayed. The column position assumes an infinite position display; it does not truncate just because the screen does. .It write-file Ask for a file name and write the contents of the current buffer to that file. Update the remembered file name and clear the buffer changed flag. .It yank Yank text from kill-buffer. Unlike emacs, the .Nm kill buffer consists only of the most recent kill. It is not a ring. .El .Sh MG DIRED KEY BINDINGS Specific key bindings are available in dired mode. .Pp .Bl -tag -width xxxxxxxxxxxxxxxxxx -offset indent -compact .It DEL dired-unmark-backward .It RET, e, f and C-m dired-find-file .It SPC dired-next-line .It ! dired-shell-command .It + dired-create-directory .It a dired-find-alternate-file .It c dired-do-copy .It d and C-d dired-flag-file-deletion .It g dired-revert .It n dired-next-line .It o dired-find-file-other-window .It p dired-previous-line .It q quit-window .It r dired-do-rename .It u dired-unmark .It x dired-do-flagged-delete .It C-v dired-scroll-down .It M-v dired-scroll-up .El .Sh MG DIRED COMMANDS The following are a list of the commands specific to dired mode: .Bl -tag -width Ds .It dired-create-directory Create a directory. .It dired-do-copy Copy the file listed on the current line of the dired buffer. .It dired-do-flagged-delete Delete the files that have been flagged for deletion. .It dired-do-rename Rename the file listed on the current line of the dired buffer. .It dired-find-alternate-file Replace the current dired buffer with an alternate one as specified by the position of the cursor in the dired buffer. .It dired-find-file Open the file on the current line of the dired buffer. If the cursor is on a directory it will be opened in dired mode. .It dired-flag-file-deletion Flag the file listed on the current line for deletion. This is indicated in the buffer by putting a D at the left margin. No files are actually deleted until the function dired-do-flagged-delete is executed. .It dired-find-file-other-window Open the file on the current line of the dired buffer in a different window. .It dired-next-line Move the cursor to the next line. .It dired-other-window This function works just like dired, except that it puts the dired buffer in another window. .It dired-previous-line Move the cursor to the previous line. .It dired-revert Refresh the dired buffer. .It dired-scroll-down Scroll down the dired buffer. .It dired-scroll-up Scroll up the dired buffer. .It dired-unmark Remove the deletion flag for the file on the current line. .It dired-unmark-backward Remove the deletion flag from the file listed on the previous line of the dired buffer, then move up to that line. .It quit-window Close the current dired buffer. .El .Sh CONFIGURATION FILES There are two configuration files, .Pa .mg and .Pa .mg-TERM . Here, .Ev TERM represents the name of the terminal type; e.g. if the terminal type is set to .Dq vt100 , .Nm will use .Pa .mg-vt100 as a startup file. The terminal type startup file is used first. .Pp The startup file format is a list of commands, one per line, as used for interactive evaluation. Strings that are normally entered by the user at any subsequent prompts may be specified after the command name; e.g.: .Bd -literal -offset indent global-set-key ")" self-insert-command global-set-key "\e^x\e^f" find-file global-set-key "\ee[Z" backward-char set-default-mode fill set-fill-column 72 auto-execute *.c c-mode .Ed .Pp Comments can be added to the startup files by placing .Dq \; or .Dq # as the first character of a line. .Sh FILES .Bl -tag -width /usr/share/doc/mg/tutorial -compact .It Pa ~/.mg normal startup file .It Pa ~/.mg-TERM terminal-specific startup file .It Pa ~/.mg.d alternative backup file location .It Pa /usr/share/doc/mg/tutorial concise tutorial .El .Sh SEE ALSO .Xr ctags 1 , .Xr vi 1 .Sh CAVEATS Since it is written completely in C, there is currently no language in which extensions can be written; however, keys can be rebound and certain parameters can be changed in startup files. .Pp In order to use 8-bit characters (such as German umlauts), the Meta key needs to be disabled via the .Dq meta-key-mode command. .Pp Multi-byte character sets, such as UTF-8, are not supported. mg-20161005/GNUmakefile010064400017510001751000000044131277516274500133250ustar00hanboetes# Makefile for mg # This Makefile has been written by Han Boetes # and is released in Public Domain. # *sigh* Those debian folks are really tidy on their licenses. name= mg prefix= /usr/local bindir= $(prefix)/bin libdir= $(prefix)/lib includedir= $(prefix)/include mandir= $(prefix)/man PKG_CONFIG= /usr/bin/pkg-config --silence-errors INSTALL= /usr/bin/install STRIP= /usr/bin/strip UNAME:= $(shell uname) ifeq ($(UNAME),FreeBSD) BSD_CPPFLAGS:= BSD_LIBS:= -lutil else BSD_CPPFLAGS:= $(shell $(PKG_CONFIG) --cflags libbsd-overlay) BSD_LIBS:= $(shell $(PKG_CONFIG) --libs libbsd-overlay) endif # Test is some required libraries are installed. Rather bummer that # they are also required to run make clean or uninstall. Oh well... Who # does that? ifeq ($(BSD_LIBS),) $(error You probably need to install "libbsd-dev" or "libbsd-devel" or something like that.) endif CURSES_LIBS:= $(shell $(PKG_CONFIG) --libs ncurses) ifeq ($(CURSES_LIBS),) $(error You probably need to install "libncurses5-dev" or "libnnurses6-devel" or something like that.) endif CC?= gcc CFLAGS?= -O2 -pipe CFLAGS+= -g -Wall CPPFLAGS= -DREGEX CPPFLAGS+= -D_GNU_SOURCE CPPFLAGS+= $(BSD_CPPFLAGS) -D__dead=__dead2 LIBS= $(CURSES_LIBS) $(BSD_LIBS) OBJS= autoexec.o basic.o bell.o buffer.o cinfo.o dir.o display.o \ echo.o extend.o file.o fileio.o funmap.o help.o kbd.o keymap.o \ line.o macro.o main.o match.o modes.o paragraph.o \ re_search.o region.o search.o spawn.o tty.o ttyio.o ttykbd.o \ undo.o util.o version.o window.o word.o yank.o OBJS+= cmode.o cscope.o dired.o grep.o tags.o # Portability stuff. CFLAGS+= -Wno-strict-aliasing -Wno-deprecated-declarations EXE_EXT= .c.o: $(CC) $(CFLAGS) $(CPPFLAGS) -c $< all: $(name) $(name): $(OBJS) $(CC) $(LDFLAGS) $(OBJS) -o $(name) $(LIBS) distclean: clean -rm -f *.core core.* clean: -rm -f *.o $(name)$(EXE_EXT) install: $(name) $(name).1 $(INSTALL) -d $(DESTDIR)$(bindir) $(INSTALL) -d $(DESTDIR)$(mandir)/man1 $(INSTALL) -m 755 $(name) $(DESTDIR)$(bindir)/$(name) $(INSTALL) -m 444 $(name).1 $(DESTDIR)$(mandir)/man1/$(name).1 install-strip: install $(STRIP) $(DESTDIR)$(bindir)/$(name) uninstall: rm -f \ $(DESTDIR)$(bindir)/$(name)$(EXE_EXT) \ $(DESTDIR)$(mandir)/man1/$(name).1 rebuild: make clean all mg-20161005/Makefile010064400017510001751000000015751277516274500127210ustar00hanboetes# $OpenBSD: Makefile,v 1.33 2016/09/16 17:17:40 tedu Exp $ PROG= mg LDADD+= -lcurses -lutil DPADD+= ${LIBCURSES} ${LIBUTIL} # (Common) compile-time options: # # REGEX -- create regular expression functions. # STARTUPFILE -- look for and handle initialization file. # CFLAGS+=-Wall -DREGEX SRCS= autoexec.c basic.c bell.c buffer.c cinfo.c dir.c display.c \ echo.c extend.c file.c fileio.c funmap.c help.c kbd.c keymap.c \ line.c macro.c main.c match.c modes.c paragraph.c \ re_search.c region.c search.c spawn.c tty.c ttyio.c ttykbd.c \ undo.c util.c version.c window.c word.c yank.c # # More or less standalone extensions. # SRCS+= cmode.c cscope.c dired.c grep.c tags.c afterinstall: ${INSTALL} -d -o root -g wheel ${DESTDIR}${DOCDIR}/mg ${INSTALL} ${INSTALL_COPY} -o ${DOCOWN} -g ${DOCGRP} -m ${DOCMODE} \ ${.CURDIR}/tutorial ${DESTDIR}${DOCDIR}/mg .include mg-20161005/README010064400017510001751000000074541276204442100121250ustar00hanboetes[This is an edited version of the original mg README, updated slightly to reflect changes in the last 20 years.] Mg (mg) is a Public Domain EMACS style editor. It is "broadly" compatible with GNU Emacs, the latest creation of Richard M. Stallman, Chief GNUisance and inventor of Emacs. GNU Emacs (and other portions of GNU as they are released) are essentially free, (there are handling charges for obtaining it) and so is Mg. You may never have to learn another editor. (But probably will, at least long enough to port Mg...) Mg was formerly named MicroGnuEmacs, the name change was done at the request of Richard Stallman. Mg is not associated with the GNU project, and it does not have the copyright restrictions present in GNU Emacs. (However, some modules do have copyright notices.) The Mg authors individually may or may not agree with the opinions expressed by Richard Stallman in "The GNU Manifesto". This program is intended to be a small, fast, and portable editor for people who can't (or don't want to) run real Emacs for one reason or another. It is compatible with GNU because there shouldn't be any reason to learn more than one Emacs flavor. Beyond the work of Dave Conroy, author of the original public domain v30, the current version contains the work of: blarson@ecla.usc.edu Bob Larson mic@emx.utexas.edu Mic Kaczmarczik mwm@violet.berkeley.edu Mike Meyer sandra@cs.utah.edu Sandra Loosemore mp1u+@andrew.cmu.edu Michael Portuesi RCKG01M@CALSTATE.BITNET Stephen Walton hakanson@mist.cs.orst.edu Marion Hakanson People who have worked on previous versions of Mg: rtech!daveb@sun.com Dave Brower Early release history: * Nov 16, 1986: First release to mod.sources * Mar 3, 1987: First Release (mg1a) via comp.sources.unix * May 26, 1988: Second release: (mg2a) via comp.sources.misc * Jan 26, 1992: Linux port released by Charles Hedrick. This version later makes its way onto tsx-11, Infomagic, and various other Linux repositories. * Feb 25, 2000: First import into the OpenBSD tree, where it is currently maintained with contributions from many others. ---------------------------------------------------------------------- Known limitations: Recursive bindings may cause help and key rebinding code to go into an infinite loop, aborting with a stack overflow. Overwrite mode does not work in macros. (Characters are inserted rather than overwriting.) Dired mode has some problems: .. and . are not recognized as special cases. Also, mg uses the output of the command 'ls' to populate a dired buffer. This is not ideal, dired mode should probably be rewritten to use the directory(3) set of functions. On systems with 16 bit integers, the kill buffer cannot exceed 32767 bytes. Unlike GNU Emacs, Mg's minibuffer isn't multi-line aware and hence some commands like "shell-command-on-region" always pop up a buffer to display output irrespective of output's size. While navigating source code using Mg's cscope commands, the cursor is always at the match location rather than in *cscope* buffer. Mg uses the same keybindings of GNU Emacs's xcscope package for it's cscope commands. As Mg's keybindings are case-insensitive some of the commands don't have a default keybinding. New implementation oddities: insert and define-key are new commands corresponding to the mocklisp functions in GNU Emacs. (Mg does not have non-command functions.) (Mg's insert will only insert one string.) The display wrap code does not work at all like that of GNU emacs. Some commands that do not mimic emacs exactly don't have a "standard" emacs name. For example 'backup-to-home-directory' is only a partial implementation of emacs' range of commands that allow a user to customise the backup file location. If a more complete implementation were coded of these commands the non standard commands would probably be removed. mg-20161005/README.md010064400017510001751000000026431276204442100125170ustar00hanboetes# PORTING MG AND USING LIBBSD I've maintained and ported mg for quite some time now and at first it was easy recently it got harder and harder since it was a moving target. Especially the inclusion of some system specific libraries since about 2 years ago made it too much of an effort for my humble coding skills. So recently Jasper Lievisse Adriaanse asked me to try it again and I restarted working on the project and ran into exactly the same problems again. While googling for solutions I ran into libbsd: http://libbsd.freedesktop.org/wiki/ It's a porting library for OpenBSD code! And after installing that it was a piece of pie to get mg ported again. ## PORTING TO ALL OTHER PLATFORMS Okay, that was debian. Now I have to get the rest of all the previously suported platforms working again. All help is welcome and as always: Please provide patches that do not break stuff for other platforms. ## BUILDING MG So, basic instructions for building mg: - Get libbsd installed. - Run the following commands: ``` make sudo make install ``` ## USING CVS This code is the cvs checkout from the OpenBSD project so if you install cvs you can see what I changed to port mg. Like this: ``` cvs diff -uw ``` ## ABOUT fgetln() Incase you are wondering about that deprecation warning, here is a nice explanation about why it is hard to fix: http://niallohiggins.com/2009/10/03/read-a-file-line-by-line-in-c-secure-fgets-idiom/ mg-20161005/tutorial010064400017510001751000000370371276204442100130330ustar00hanboetesThe mg Tutorial --------------- The mg editor is a public domain editor intended to loosely resemble GNU Emacs, while still retaining fast speed and a small memory footprint. Most mg commands involve using the Control (sometimes labelled "Ctrl") or the Meta (sometimes labelled "Alt") key. We will use the following conventions in this tutorial: C- means hold down the Control key while typing the character . M- means hold down the Meta key while typing the character . If you don't have a Meta key, you can use Esc instead. Press and release the Esc key and type . This is equivalent to M-. The first thing to learn is how to move up and down a document. To move your cursor down a line, use the down-arrow cursor key or C-n (Control and n). >> Now type C-n multiple times and move your cursor past this line. Congratulations. You have now learned how to move your cursor down. To move your cursor up one line, you can use the up-arrow cursor key or C-p (Control and p). >> Try using C-p and C-n to move up and down and then move past this line. The next commands to learn are how to move your cursor left and right. To do this, you can use the left-arrow and right-arrow cursor keys. Alternatively, you can use C-b and C-f to do this. >> Practise using the arrow keys or C-b and C-f on this line. To make it easy to remember these commands, it helps to remember by letter: P - Previous line, N - Next line, B - Backwards and F - Forward. Now that you've learned how to move single characters at a time, next we learn how to move one word at a time. To do this, you can use M-f (Meta and f) or M-b (Meta and b) to move forwards and backwards, one word at a time. >> Try moving one word at a time by using M-f and M-b on this line. Notice how the Ctrl and Meta key combinations perform related functions. C-f moves one letter forward, whereas M-f moves one word forward. There are many key combinations in mg, where C- will perform one function and M- will perform a similar related function. Most probably by now you have moved passed the bottom of the text which was initially shown to you when you opened this document. mg redraws your terminal screen so that the cursor is in the middle. This is a feature of mg, which allows you to see the lines before and after the current cursor position. The same effect can be achieved manually. >> Now move the cursor down to this line and then type C-l (that's Control and lowercase L). Note that C-l refreshes the screen and centers it on the line you typed it on. To move to the beginning or end of a line, you can use the Home and End keys, or you can use C-a and C-e to move to the beginning and end. >> Use C-a and C-e to move to the beginning and end of this line. The next commands we will learn is how to move up and down, one page at a time. To do this, you can use the Page Up (sometimes labelled PgUp) and Page Down (sometimes labelled PgDn) keys. You can also use C-v and M-v to do this. C-v moves the cursor down one page and M-v moves it up one page. >> Try using M-v and C-v to move up and down, one page at a time. The final two motion commands we will learn are M-< (Meta-Less than) and M-> (Meta-Greater than) which move you to the beginning and end of a file, respectively. You may not want to try that now as you will probably lose your place in this tutorial. Note that on most terminals, < is above the , key, so you'll need to press the Shift key to type <. Movement Summary ----------------- The following is a summary of the movement commands we've learned so far: C-f Move forward one character (can also use right arrow key). C-b Move backward one character (can also use left arrow key). C-p Move up one line (can also use up arrow key). C-n Move down one line (can also use down arrow key). M-f Move forward one word. M-b Move backward one word. C-a Move to beginning of line (can also use Home key). C-e Move to end of line (can also use End key). C-v Move forward one page (can also use PgDn/Page Down key). M-v Move backward one page (can also use PgUp/Page Up key). M-< Move to beginning of file. M-> Move to end of file. Now that you've mastered the basics of moving around in mg, you can cause mg to execute these commands multiple times. The way to do this is to type C-u followed by some digits followed by a movement command. >> Type C-u 5 C-f to move forward 5 characters. In general, C-u allows you to execute any command multiple times, not just cursor motion commands. The only exception to this rule are C-v and M-v. When using these two commands with an argument, they move the cursor by that many lines instead of pages. Cancelling mg Commands ---------------------- If you have started typing out a command that you didn't mean to finish, you can use the C-g command to cancel the command immediately. >> For example, type C-u 50 and then type C-g to cancel the C-u command. >> Type Esc and then C-g to cancel the Esc key. In general, you can use C-g to stop any mg commands. You may type it multiple times if you wish. You should see the word "Quit" appear in the bottom of the screen when you type C-g indicating that a command was cancelled. In general, when in doubt, use C-g to get out of trouble. Inserting/Deleting Text ----------------------- To insert text anywhere, simply move your cursor to the appropriate position and begin typing. To delete characters, use the backspace key. If you use M- (Meta and backspace key), you will delete one word instead of one character at a time. To delete characters to the right of the cursor, you can use C-d to delete characters to the right of the current position. If you use M-d instead of C-d, you can delete one word at a time instead of one character at a time. >> Try inserting and deleting characters and words on this line. Note that if you type too many characters on a single line, the line will scroll off the screen and you will see a $ on the line to indicate that the line is too long to fit on the screen at one time. To delete a line at a time, you can use C-k to kill the line from the current cursor position to the end of the line. You can type C-k multiple times to kill many lines. You can issue insert or delete commands multiple times using C-u. For example, C-u 10 e will type out eeeeeeeeee, C-u 4 M-d will delete four words to the right of the cursor and so on. To undo any operation, you can use C-_ (that's control-underscore). Now if you kill something that you didn't mean to, you can yank it back from the dead by using C-y. In general, when you kill something bigger than a single character, mg saves it in a buffer somewhere and you can restore it by using C-y. This is useful for moving text around. You can kill text in one place, move your cursor to the new location and then use C-y to paste it there. Search for Text --------------- To search for text, type C-s followed by the text you wish to search for. Note that as you start typing the characters, mg automatically searches as you type the characters. To continue searching the text you're looking for, type C-s to find the next instance. To search in reverse, type C-r instead of C-s. If you type C-s or C-r twice, it will simply search for the last text that you searched for. To stop searching for text, simply use the cursor keys (or C-f, C-b etc.) or C-g to stop the search operation. >> Use C-s foo to search for "foo" in the text. You can use C-s again to find other instances of foo in the file. Note that if a word cannot be found, it will say Failing I-search: at the bottom of the screen. Typing C-s again will wrap the search around from the top of the file and begin searching from there. Replace Text ------------ To replace text, use M-%. You will be prompted for the text to search for and the text to replace it with. You will then be taken to the first instance of text from the current position. At this point you can do one of the following: y - Replace the text at this instance and search for more items. n - Skip this instance and search for more items. . or Enter - Stop replacing text (you can also use C-g). ! - Replace all the instances without prompting at each one. >> Try replacing "frobnitz" with "zutwalt" on this line. Cut/Copy/Paste Text ------------------- As explained above, you can cut regions using C-k to kill multiple lines. To paste the text that you just cut, simply move your cursor to the point and then type C-y to restore the text. You may type C-y multiple times to restore the text. Hence, to copy text, you can use C-k to kill all the lines, use C-y to restore it immediately, then move to the region you want to copy it to and then type C-y again to restore the last cut text block again. Another way to cut or copy chunks of text is to first position your cursor at the starting point of the chunk of text. Then type C- to mark this as the starting point to cut or copy. Then move the cursor to the end point of the text chunk that you wish to manipulate. Then type C-w to cut the region, or M-w to copy the region. If you wish to cancel marking a block of text, simply type C-g to cancel the operation. To paste the region that you've cut or copied above, simply move your cursor to the desired location and then type C-y to paste it. Status Line ----------- At the bottom of your screen is a reverse highlighted line. This is the status line and lets you know some useful information about the file you're editing. On the status line, you should see "Mg: tutorial". This lets you know that you're editing a file named "tutorial". If you've edited this file and not saved it, it should have a "**" to the left of those words. If this file is read-only, you should see a "%%" to the left of those words. To the right of the status line, you should see L followed by digits and C followed by some more digits. These indicate the line number and column number of the file that your cursor is currently on. If you move the cursor around, you should see the line and column number change. In the middle of the screen, you should see the word "(fundamental)" which indicates that the current editing mode is "fundamental-mode". The mg editor also supports a c-mode that is more suited to editing C code. There are also some other useful editing modes for different situations. See the man page for mg(1) to learn about the various editing modes. Opening and Saving Files ------------------------ To open a file, you can use C-x C-f. You will then be prompted for a file name. If you type a file name that doesn't already exist, a new file will be opened for you. If the file name already exists, then it will be opened for you and you can begin editing it. Note that you do not need to type the whole file name for an existing file. You can type part of the file name and then press the TAB key. If there is only file name that matches, mg will fill in the rest of the file name for you. If there are multiple files, mg will display that the choice is ambiguous. If you type the TAB key again, mg will show you all the available choices for file names. NOTE: If you type C-x f instead of C-x C-f, you can use C-g to cancel the Set-Fill-Column command. You can also use C-g to cancel the C-x C-f command if you don't wish to open a new file. To save the file once you've edited it, use C-x C-s to save the file. When mg is done saving the file, you should see the words "Wrote /path/to/file" in the bottom of your screen. In general, it is a good idea to save quite often. When you save a file, mg saves a backup of the file with a tilde (~) character at the end. If you decide to open a directory instead of a file, mg will transistion into a mode called dired. Dired fills a buffer with the contents of the selected directory, one file or sub-directory's details per line. Some basic file management functions can be performed on the files and sub-directories in the buffer. For example, with the cursor over a specific file: Pressing c will give you the opportunity to copy the file. Pressing d will mark the file for deletion. Pressing x will unlink files previously marked for deletion. Pressing Return will open the highlighted file into it's own buffer for editing. There are more dired commands, see the man page for further information. Working with Buffers and Windows -------------------------------- Once a file is loaded into mg, it is often referred to as a buffer. The mg editor is capable of editing multiple buffers at the same time. When you open a second file with C-x C-f, the first buffer is still being edited by mg. Both buffers can be viewed simultaneously because mg can support several windows at the same time, each one displaying different text. To split a screen into two horizontal windows use C-x 2. To return to one window, use C-x 1 to close the other windows and only keep the current window. >> Use C-x 2 to split the screen into two windows. >> Use C-x o to move from one window to the other. You can scroll up and down in each window using the cursor keys or C-n and C-p keys. >> Use C-x 1 to restore back to one window. You can list all the buffers that are opened by mg by typing C-x C-b. The screen should divide into two and the top window will list the buffers that are currently open. Use C-x o to switch to the top window, then use the arrow keys to move to the buffer you wish to switch to, and then type the Enter key to select that buffer. Then use C-x 1 to switch back to only one window. You may also move back to the last opened buffer by using C-x b to toggle back and forth between two buffers. Note the difference between C-x b and C-x C-b. >> Use C-x C-f to open a new file >> Use C-x b to switch back and forth between that buffer and this one. To kill any buffer, use C-x k. You will be prompted for the buffer to kill. By default, the current buffer is selected as the one to kill. You may also type another buffer name or use C-g to cancel the operation. Extended Commands ----------------- The mg editor has several extended commands, more than what can be covered by the Control and Meta keys. The mg editor gets around this by using what is called the X (eXtend) command. There are two forms of this: C-x Character eXtension. Followed by one character. M-x Named character eXtension. Followed by a long command. You've already seen C-x C-f and C-x C-s to open and save a file. There are other longer commands. For instance, you can also open a file by typing M-x open-file Enter. When you type a command using M-x, mg prompts you for the command at the bottom of the screen. You can type out the whole command if you wish, or you can type out part of the command and then use the TAB key for autocompleting the command. For instance, to replace text, you can type M-x repl TAB enter to execute the replace-text command. To cancel this command, type C-g. To see a list of all available mg(1) commands, consult the man page. Exiting mg ---------- To exit mg temporarily and return to the shell, use C-z. This will take you back to the command shell. To return back to mg, type fg in the shell and you will be returned to your mg session. To exit mg permanently, type C-x C-c. If you have any unsaved buffers, you will be asked if you wish to save them or not. Conclusion ---------- This tutorial is meant to get new users up and running with mg. There is more information available via the mg(1) man page. If you have any suggestions for improvement, please don't hesitate to drop a message or (better still) submit a diff to tech@openbsd.org. Author Info ----------- Original Author of this document: Mayukh Bose, Date last updated: 2015-12-21 Copyright --------- None. This document is in the public domain. mg-20161005/CVS004075500017510001751000000000001277516274500116305ustar00hanboetesmg-20161005/CVS/Repository010064400017510001751000000000171276204442000137650ustar00hanboetessrc/usr.bin/mg mg-20161005/CVS/Entries010064400017510001751000000037341277516274500132470ustar00hanboetes/ttyio.c/1.37/Wed Mar 25 18:47:22 2015// /def.h/1.155/Result of merge// /fileio.c/1.103/Result of merge// /tags.c/1.14/Result of merge// /region.c/1.37/Result of merge// /Makefile/1.33/Wed Oct 5 11:32:26 2016// /README/1.14/Mon Sep 5 05:50:39 2016// /autoexec.c/1.17/Mon Sep 5 05:50:39 2016// /basic.c/1.47/Mon Sep 5 05:50:39 2016// /bell.c/1.4/Mon Sep 5 05:50:39 2016// /buffer.c/1.102/Mon Sep 12 16:38:18 2016// /chrdef.h/1.10/Mon Sep 5 05:50:39 2016// /cinfo.c/1.18/Mon Sep 5 05:50:39 2016// /cmode.c/1.16/Mon Sep 5 05:50:39 2016// /cscope.c/1.16/Mon Sep 5 05:50:39 2016// /dir.c/1.29/Wed Oct 5 11:32:26 2016// /dired.c/1.82/Mon Sep 5 05:50:39 2016// /display.c/1.47/Mon Sep 5 05:50:39 2016// /echo.c/1.65/Mon Sep 5 05:50:39 2016// /extend.c/1.64/Mon Sep 12 16:38:18 2016// /file.c/1.100/Mon Sep 5 05:50:39 2016// /funmap.c/1.53/Mon Sep 5 05:50:39 2016// /funmap.h/1.7/Mon Sep 5 05:50:39 2016// /grep.c/1.44/Mon Sep 5 05:50:39 2016// /help.c/1.35/Mon Sep 5 05:50:39 2016// /kbd.c/1.30/Mon Sep 5 05:50:39 2016// /kbd.h/1.19/Mon Sep 5 05:50:39 2016// /key.h/1.5/Mon Sep 5 05:50:39 2016// /keymap.c/1.58/Mon Sep 5 05:50:39 2016// /line.c/1.58/Mon Sep 5 05:50:39 2016// /macro.c/1.16/Mon Sep 5 05:50:39 2016// /macro.h/1.7/Mon Sep 5 05:50:39 2016// /main.c/1.84/Result of merge// /match.c/1.19/Mon Sep 5 05:50:39 2016// /mg.1/1.105/Mon Sep 5 05:50:39 2016// /modes.c/1.20/Mon Sep 5 05:50:39 2016// /paragraph.c/1.45/Mon Sep 12 16:38:18 2016// /pathnames.h/1.1/Mon Sep 5 05:50:39 2016// /re_search.c/1.31/Mon Sep 5 05:50:39 2016// /search.c/1.44/Mon Sep 5 05:50:39 2016// /spawn.c/1.12/Mon Sep 5 05:50:39 2016// /tty.c/1.36/Mon Sep 5 05:50:39 2016// /ttykbd.c/1.18/Mon Sep 5 05:50:39 2016// /tutorial/1.16/Mon Sep 5 05:50:39 2016// /undo.c/1.58/Mon Sep 12 16:38:18 2016// /util.c/1.38/Mon Sep 5 05:50:39 2016// /version.c/1.10/Mon Sep 5 05:50:39 2016// /window.c/1.36/Mon Sep 5 05:50:39 2016// /word.c/1.19/Mon Sep 5 05:50:39 2016// /yank.c/1.14/Mon Sep 5 05:50:39 2016// D mg-20161005/CVS/Root010064400017510001751000000000441276204442000125310ustar00hanboetesanoncvs@anoncvs.fr.openbsd.org:/cvs