| /* random.c |
| * |
| * This file contains the command processing functions for a number of |
| * random commands. There is no functional grouping here, for sure. |
| * |
| * Modified by Petri Kutvonen |
| */ |
| |
| #include <stdio.h> |
| |
| #include "estruct.h" |
| #include "edef.h" |
| #include "efunc.h" |
| #include "line.h" |
| |
| int tabsize; /* Tab size (0: use real tabs) */ |
| |
| /* |
| * Set fill column to n. |
| */ |
| int setfillcol(int f, int n) |
| { |
| fillcol = n; |
| mlwrite("(Fill column is %d)", n); |
| return TRUE; |
| } |
| |
| /* |
| * Display the current position of the cursor, in origin 1 X-Y coordinates, |
| * the character that is under the cursor (in hex), and the fraction of the |
| * text that is before the cursor. The displayed column is not the current |
| * column, but the column that would be used on an infinite width display. |
| * Normally this is bound to "C-X =". |
| */ |
| int showcpos(int f, int n) |
| { |
| struct line *lp; /* current line */ |
| long numchars; /* # of chars in file */ |
| int numlines; /* # of lines in file */ |
| long predchars; /* # chars preceding point */ |
| int predlines; /* # lines preceding point */ |
| int curchar; /* character under cursor */ |
| int ratio; |
| int col; |
| int savepos; /* temp save for current offset */ |
| int ecol; /* column pos/end of current line */ |
| |
| /* starting at the beginning of the buffer */ |
| lp = lforw(curbp->b_linep); |
| |
| /* start counting chars and lines */ |
| numchars = 0; |
| numlines = 0; |
| predchars = 0; |
| predlines = 0; |
| curchar = 0; |
| while (lp != curbp->b_linep) { |
| /* if we are on the current line, record it */ |
| if (lp == curwp->w_dotp) { |
| predlines = numlines; |
| predchars = numchars + curwp->w_doto; |
| if ((curwp->w_doto) == llength(lp)) |
| curchar = '\n'; |
| else |
| curchar = lgetc(lp, curwp->w_doto); |
| } |
| /* on to the next line */ |
| ++numlines; |
| numchars += llength(lp) + 1; |
| lp = lforw(lp); |
| } |
| |
| /* if at end of file, record it */ |
| if (curwp->w_dotp == curbp->b_linep) { |
| predlines = numlines; |
| predchars = numchars; |
| #if PKCODE |
| curchar = 0; |
| #endif |
| } |
| |
| /* Get real column and end-of-line column. */ |
| col = getccol(FALSE); |
| savepos = curwp->w_doto; |
| curwp->w_doto = llength(curwp->w_dotp); |
| ecol = getccol(FALSE); |
| curwp->w_doto = savepos; |
| |
| ratio = 0; /* Ratio before dot. */ |
| if (numchars != 0) |
| ratio = (100L * predchars) / numchars; |
| |
| /* summarize and report the info */ |
| mlwrite("Line %d/%d Col %d/%d Char %D/%D (%d%%) char = 0x%x", |
| predlines + 1, numlines + 1, col, ecol, |
| predchars, numchars, ratio, curchar); |
| return TRUE; |
| } |
| |
| int getcline(void) |
| { /* get the current line number */ |
| struct line *lp; /* current line */ |
| int numlines; /* # of lines before point */ |
| |
| /* starting at the beginning of the buffer */ |
| lp = lforw(curbp->b_linep); |
| |
| /* start counting lines */ |
| numlines = 0; |
| while (lp != curbp->b_linep) { |
| /* if we are on the current line, record it */ |
| if (lp == curwp->w_dotp) |
| break; |
| ++numlines; |
| lp = lforw(lp); |
| } |
| |
| /* and return the resulting count */ |
| return numlines + 1; |
| } |
| |
| /* |
| * Return current column. Stop at first non-blank given TRUE argument. |
| */ |
| int getccol(int bflg) |
| { |
| int c, i, col; |
| col = 0; |
| for (i = 0; i < curwp->w_doto; ++i) { |
| c = lgetc(curwp->w_dotp, i); |
| if (c != ' ' && c != '\t' && bflg) |
| break; |
| if (c == '\t') |
| col |= tabmask; |
| else if (c < 0x20 || c == 0x7F) |
| ++col; |
| ++col; |
| } |
| return col; |
| } |
| |
| /* |
| * Set current column. |
| * |
| * int pos; position to set cursor |
| */ |
| int setccol(int pos) |
| { |
| int c; /* character being scanned */ |
| int i; /* index into current line */ |
| int col; /* current cursor column */ |
| int llen; /* length of line in bytes */ |
| |
| col = 0; |
| llen = llength(curwp->w_dotp); |
| |
| /* scan the line until we are at or past the target column */ |
| for (i = 0; i < llen; ++i) { |
| /* upon reaching the target, drop out */ |
| if (col >= pos) |
| break; |
| |
| /* advance one character */ |
| c = lgetc(curwp->w_dotp, i); |
| if (c == '\t') |
| col |= tabmask; |
| else if (c < 0x20 || c == 0x7F) |
| ++col; |
| ++col; |
| } |
| |
| /* set us at the new position */ |
| curwp->w_doto = i; |
| |
| /* and tell weather we made it */ |
| return col >= pos; |
| } |
| |
| /* |
| * Twiddle the two characters on either side of dot. If dot is at the end of |
| * the line twiddle the two characters before it. Return with an error if dot |
| * is at the beginning of line; it seems to be a bit pointless to make this |
| * work. This fixes up a very common typo with a single stroke. Normally bound |
| * to "C-T". This always works within a line, so "WFEDIT" is good enough. |
| */ |
| int twiddle(int f, int n) |
| { |
| struct line *dotp; |
| int doto; |
| int cl; |
| int cr; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| dotp = curwp->w_dotp; |
| doto = curwp->w_doto; |
| if (doto == llength(dotp) && --doto < 0) |
| return FALSE; |
| cr = lgetc(dotp, doto); |
| if (--doto < 0) |
| return FALSE; |
| cl = lgetc(dotp, doto); |
| lputc(dotp, doto + 0, cr); |
| lputc(dotp, doto + 1, cl); |
| lchange(WFEDIT); |
| return TRUE; |
| } |
| |
| /* |
| * Quote the next character, and insert it into the buffer. All the characters |
| * are taken literally, with the exception of the newline, which always has |
| * its line splitting meaning. The character is always read, even if it is |
| * inserted 0 times, for regularity. Bound to "C-Q" |
| */ |
| int quote(int f, int n) |
| { |
| int s; |
| int c; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| c = tgetc(); |
| if (n < 0) |
| return FALSE; |
| if (n == 0) |
| return TRUE; |
| if (c == '\n') { |
| do { |
| s = lnewline(); |
| } while (s == TRUE && --n); |
| return s; |
| } |
| return linsert(n, c); |
| } |
| |
| /* |
| * Set tab size if given non-default argument (n <> 1). Otherwise, insert a |
| * tab into file. If given argument, n, of zero, change to true tabs. |
| * If n > 1, simulate tab stop every n-characters using spaces. This has to be |
| * done in this slightly funny way because the tab (in ASCII) has been turned |
| * into "C-I" (in 10 bit code) already. Bound to "C-I". |
| */ |
| int insert_tab(int f, int n) |
| { |
| if (n < 0) |
| return FALSE; |
| if (n == 0 || n > 1) { |
| tabsize = n; |
| return TRUE; |
| } |
| if (!tabsize) |
| return linsert(1, '\t'); |
| return linsert(tabsize - (getccol(FALSE) % tabsize), ' '); |
| } |
| |
| #if AEDIT |
| /* |
| * change tabs to spaces |
| * |
| * int f, n; default flag and numeric repeat count |
| */ |
| int detab(int f, int n) |
| { |
| int inc; /* increment to next line [sgn(n)] */ |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| |
| if (f == FALSE) |
| n = 1; |
| |
| /* loop thru detabbing n lines */ |
| inc = ((n > 0) ? 1 : -1); |
| while (n) { |
| curwp->w_doto = 0; /* start at the beginning */ |
| |
| /* detab the entire current line */ |
| while (curwp->w_doto < llength(curwp->w_dotp)) { |
| /* if we have a tab */ |
| if (lgetc(curwp->w_dotp, curwp->w_doto) == '\t') { |
| ldelete(1L, FALSE); |
| insspace(TRUE, |
| (tabmask + 1) - |
| (curwp->w_doto & tabmask)); |
| } |
| forwchar(FALSE, 1); |
| } |
| |
| /* advance/or back to the next line */ |
| forwline(TRUE, inc); |
| n -= inc; |
| } |
| curwp->w_doto = 0; /* to the begining of the line */ |
| thisflag &= ~CFCPCN; /* flag that this resets the goal column */ |
| lchange(WFEDIT); /* yes, we have made at least an edit */ |
| return TRUE; |
| } |
| |
| /* |
| * change spaces to tabs where posible |
| * |
| * int f, n; default flag and numeric repeat count |
| */ |
| int entab(int f, int n) |
| { |
| int inc; /* increment to next line [sgn(n)] */ |
| int fspace; /* pointer to first space if in a run */ |
| int ccol; /* current cursor column */ |
| char cchar; /* current character */ |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| |
| if (f == FALSE) |
| n = 1; |
| |
| /* loop thru entabbing n lines */ |
| inc = ((n > 0) ? 1 : -1); |
| while (n) { |
| curwp->w_doto = 0; /* start at the beginning */ |
| |
| /* entab the entire current line */ |
| fspace = -1; |
| ccol = 0; |
| while (curwp->w_doto < llength(curwp->w_dotp)) { |
| /* see if it is time to compress */ |
| if ((fspace >= 0) && (nextab(fspace) <= ccol)) { |
| if (ccol - fspace < 2) |
| fspace = -1; |
| else { |
| /* there is a bug here dealing with mixed space/tabed |
| lines.......it will get fixed */ |
| backchar(TRUE, ccol - fspace); |
| ldelete((long) (ccol - fspace), |
| FALSE); |
| linsert(1, '\t'); |
| fspace = -1; |
| } |
| } |
| |
| /* get the current character */ |
| cchar = lgetc(curwp->w_dotp, curwp->w_doto); |
| |
| switch (cchar) { |
| case '\t': /* a tab...count em up */ |
| ccol = nextab(ccol); |
| break; |
| |
| case ' ': /* a space...compress? */ |
| if (fspace == -1) |
| fspace = ccol; |
| ccol++; |
| break; |
| |
| default: /* any other char...just count */ |
| ccol++; |
| fspace = -1; |
| break; |
| } |
| forwchar(FALSE, 1); |
| } |
| |
| /* advance/or back to the next line */ |
| forwline(TRUE, inc); |
| n -= inc; |
| } |
| curwp->w_doto = 0; /* to the begining of the line */ |
| thisflag &= ~CFCPCN; /* flag that this resets the goal column */ |
| lchange(WFEDIT); /* yes, we have made at least an edit */ |
| return TRUE; |
| } |
| |
| /* |
| * trim trailing whitespace from the point to eol |
| * |
| * int f, n; default flag and numeric repeat count |
| */ |
| int trim(int f, int n) |
| { |
| struct line *lp; /* current line pointer */ |
| int offset; /* original line offset position */ |
| int length; /* current length */ |
| int inc; /* increment to next line [sgn(n)] */ |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| |
| if (f == FALSE) |
| n = 1; |
| |
| /* loop thru trimming n lines */ |
| inc = ((n > 0) ? 1 : -1); |
| while (n) { |
| lp = curwp->w_dotp; /* find current line text */ |
| offset = curwp->w_doto; /* save original offset */ |
| length = lp->l_used; /* find current length */ |
| |
| /* trim the current line */ |
| while (length > offset) { |
| if (lgetc(lp, length - 1) != ' ' && |
| lgetc(lp, length - 1) != '\t') |
| break; |
| length--; |
| } |
| lp->l_used = length; |
| |
| /* advance/or back to the next line */ |
| forwline(TRUE, inc); |
| n -= inc; |
| } |
| lchange(WFEDIT); |
| thisflag &= ~CFCPCN; /* flag that this resets the goal column */ |
| return TRUE; |
| } |
| #endif |
| |
| /* |
| * 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 |
| * procerssors. They even handle the looping. Normally this is bound to "C-O". |
| */ |
| int openline(int f, int n) |
| { |
| int i; |
| int s; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if (n < 0) |
| return FALSE; |
| if (n == 0) |
| return TRUE; |
| i = n; /* Insert newlines. */ |
| do { |
| s = lnewline(); |
| } while (s == TRUE && --i); |
| if (s == TRUE) /* Then back up overtop */ |
| s = backchar(f, n); /* of them all. */ |
| return s; |
| } |
| |
| /* |
| * Insert a newline. Bound to "C-M". If we are in CMODE, do automatic |
| * indentation as specified. |
| */ |
| int insert_newline(int f, int n) |
| { |
| int s; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if (n < 0) |
| return FALSE; |
| |
| /* if we are in C mode and this is a default <NL> */ |
| if (n == 1 && (curbp->b_mode & MDCMOD) && |
| curwp->w_dotp != curbp->b_linep) |
| return cinsert(); |
| |
| /* |
| * If a newline was typed, fill column is defined, the argument is non- |
| * negative, wrap mode is enabled, and we are now past fill column, |
| * and we are not read-only, perform word wrap. |
| */ |
| if ((curwp->w_bufp->b_mode & MDWRAP) && fillcol > 0 && |
| getccol(FALSE) > fillcol && |
| (curwp->w_bufp->b_mode & MDVIEW) == FALSE) |
| execute(META | SPEC | 'W', FALSE, 1); |
| |
| /* insert some lines */ |
| while (n--) { |
| if ((s = lnewline()) != TRUE) |
| return s; |
| #if SCROLLCODE |
| curwp->w_flag |= WFINS; |
| #endif |
| } |
| return TRUE; |
| } |
| |
| int cinsert(void) |
| { /* insert a newline and indentation for C */ |
| char *cptr; /* string pointer into text to copy */ |
| int tptr; /* index to scan into line */ |
| int bracef; /* was there a brace at the end of line? */ |
| int i; |
| char ichar[NSTRING]; /* buffer to hold indent of last line */ |
| |
| /* grab a pointer to text to copy indentation from */ |
| cptr = &curwp->w_dotp->l_text[0]; |
| |
| /* check for a brace */ |
| tptr = curwp->w_doto - 1; |
| bracef = (cptr[tptr] == '{'); |
| |
| /* save the indent of the previous line */ |
| i = 0; |
| while ((i < tptr) && (cptr[i] == ' ' || cptr[i] == '\t') |
| && (i < NSTRING - 1)) { |
| ichar[i] = cptr[i]; |
| ++i; |
| } |
| ichar[i] = 0; /* terminate it */ |
| |
| /* put in the newline */ |
| if (lnewline() == FALSE) |
| return FALSE; |
| |
| /* and the saved indentation */ |
| linstr(ichar); |
| |
| /* and one more tab for a brace */ |
| if (bracef) |
| insert_tab(FALSE, 1); |
| |
| #if SCROLLCODE |
| curwp->w_flag |= WFINS; |
| #endif |
| return TRUE; |
| } |
| |
| #if NBRACE |
| /* |
| * insert a brace into the text here...we are in CMODE |
| * |
| * int n; repeat count |
| * int c; brace to insert (always } for now) |
| */ |
| int insbrace(int n, int c) |
| { |
| int ch; /* last character before input */ |
| int oc; /* caractere oppose a c */ |
| int i, count; |
| int target; /* column brace should go after */ |
| struct line *oldlp; |
| int oldoff; |
| |
| /* if we aren't at the beginning of the line... */ |
| if (curwp->w_doto != 0) |
| |
| /* scan to see if all space before this is white space */ |
| for (i = curwp->w_doto - 1; i >= 0; --i) { |
| ch = lgetc(curwp->w_dotp, i); |
| if (ch != ' ' && ch != '\t') |
| return linsert(n, c); |
| } |
| |
| /* chercher le caractere oppose correspondant */ |
| switch (c) { |
| case '}': |
| oc = '{'; |
| break; |
| case ']': |
| oc = '['; |
| break; |
| case ')': |
| oc = '('; |
| break; |
| default: |
| return FALSE; |
| } |
| |
| oldlp = curwp->w_dotp; |
| oldoff = curwp->w_doto; |
| |
| count = 1; |
| backchar(FALSE, 1); |
| |
| while (count > 0) { |
| if (curwp->w_doto == llength(curwp->w_dotp)) |
| ch = '\n'; |
| else |
| ch = lgetc(curwp->w_dotp, curwp->w_doto); |
| |
| if (ch == c) |
| ++count; |
| if (ch == oc) |
| --count; |
| |
| backchar(FALSE, 1); |
| if (boundry(curwp->w_dotp, curwp->w_doto, REVERSE)) |
| break; |
| } |
| |
| if (count != 0) { /* no match */ |
| curwp->w_dotp = oldlp; |
| curwp->w_doto = oldoff; |
| return linsert(n, c); |
| } |
| |
| curwp->w_doto = 0; /* debut de ligne */ |
| /* aller au debut de la ligne apres la tabulation */ |
| while ((ch = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' |
| || ch == '\t') |
| forwchar(FALSE, 1); |
| |
| /* delete back first */ |
| target = getccol(FALSE); /* c'est l'indent que l'on doit avoir */ |
| curwp->w_dotp = oldlp; |
| curwp->w_doto = oldoff; |
| |
| while (target != getccol(FALSE)) { |
| if (target < getccol(FALSE)) /* on doit detruire des caracteres */ |
| while (getccol(FALSE) > target) |
| backdel(FALSE, 1); |
| else { /* on doit en inserer */ |
| while (target - getccol(FALSE) >= 8) |
| linsert(1, '\t'); |
| linsert(target - getccol(FALSE), ' '); |
| } |
| } |
| |
| /* and insert the required brace(s) */ |
| return linsert(n, c); |
| } |
| |
| #else |
| |
| /* |
| * insert a brace into the text here...we are in CMODE |
| * |
| * int n; repeat count |
| * int c; brace to insert (always { for now) |
| */ |
| int insbrace(int n, int c) |
| { |
| int ch; /* last character before input */ |
| int i; |
| int target; /* column brace should go after */ |
| |
| /* if we are at the beginning of the line, no go */ |
| if (curwp->w_doto == 0) |
| return linsert(n, c); |
| |
| /* scan to see if all space before this is white space */ |
| for (i = curwp->w_doto - 1; i >= 0; --i) { |
| ch = lgetc(curwp->w_dotp, i); |
| if (ch != ' ' && ch != '\t') |
| return linsert(n, c); |
| } |
| |
| /* delete back first */ |
| target = getccol(FALSE); /* calc where we will delete to */ |
| target -= 1; |
| target -= target % (tabsize == 0 ? 8 : tabsize); |
| while (getccol(FALSE) > target) |
| backdel(FALSE, 1); |
| |
| /* and insert the required brace(s) */ |
| return linsert(n, c); |
| } |
| #endif |
| |
| int inspound(void) |
| { /* insert a # into the text here...we are in CMODE */ |
| int ch; /* last character before input */ |
| int i; |
| |
| /* if we are at the beginning of the line, no go */ |
| if (curwp->w_doto == 0) |
| return linsert(1, '#'); |
| |
| /* scan to see if all space before this is white space */ |
| for (i = curwp->w_doto - 1; i >= 0; --i) { |
| ch = lgetc(curwp->w_dotp, i); |
| if (ch != ' ' && ch != '\t') |
| return linsert(1, '#'); |
| } |
| |
| /* delete back first */ |
| while (getccol(FALSE) >= 1) |
| backdel(FALSE, 1); |
| |
| /* and insert the required pound */ |
| return linsert(1, '#'); |
| } |
| |
| /* |
| * 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. |
| */ |
| int deblank(int f, int n) |
| { |
| struct line *lp1; |
| struct line *lp2; |
| long nld; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| lp1 = curwp->w_dotp; |
| while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_linep) |
| lp1 = lp2; |
| lp2 = lp1; |
| nld = 0; |
| while ((lp2 = lforw(lp2)) != curbp->b_linep && llength(lp2) == 0) |
| ++nld; |
| if (nld == 0) |
| return TRUE; |
| curwp->w_dotp = lforw(lp1); |
| curwp->w_doto = 0; |
| return ldelete(nld, FALSE); |
| } |
| |
| /* |
| * 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 |
| * subcomands failed. Normally bound to "C-J". |
| */ |
| int indent(int f, int n) |
| { |
| int nicol; |
| int c; |
| int i; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if (n < 0) |
| return FALSE; |
| 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 |= tabmask; |
| ++nicol; |
| } |
| if (lnewline() == FALSE |
| || ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) |
| || ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE)) |
| return FALSE; |
| } |
| 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". |
| */ |
| int forwdel(int f, int n) |
| { |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if (n < 0) |
| return backdel(f, -n); |
| if (f != FALSE) { /* Really a kill. */ |
| if ((lastflag & CFKILL) == 0) |
| kdelete(); |
| thisflag |= CFKILL; |
| } |
| return ldelete((long) n, f); |
| } |
| |
| /* |
| * 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. Bound to |
| * both "RUBOUT" and "C-H". |
| */ |
| int backdel(int f, int n) |
| { |
| int s; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if (n < 0) |
| return forwdel(f, -n); |
| if (f != FALSE) { /* Really a kill. */ |
| if ((lastflag & CFKILL) == 0) |
| kdelete(); |
| thisflag |= CFKILL; |
| } |
| if ((s = backchar(f, n)) == TRUE) |
| s = ldelete((long) n, f); |
| return s; |
| } |
| |
| /* |
| * Kill text. 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 backwards |
| * that number of newlines. Normally bound to "C-K". |
| */ |
| int killtext(int f, int n) |
| { |
| struct line *nextp; |
| long chunk; |
| |
| if (curbp->b_mode & MDVIEW) /* don't allow this command if */ |
| return rdonly(); /* we are in read only mode */ |
| if ((lastflag & CFKILL) == 0) /* Clear kill buffer if */ |
| kdelete(); /* last wasn't a kill. */ |
| thisflag |= CFKILL; |
| if (f == FALSE) { |
| chunk = llength(curwp->w_dotp) - curwp->w_doto; |
| if (chunk == 0) |
| chunk = 1; |
| } else if (n == 0) { |
| chunk = curwp->w_doto; |
| curwp->w_doto = 0; |
| } else if (n > 0) { |
| chunk = llength(curwp->w_dotp) - curwp->w_doto + 1; |
| nextp = lforw(curwp->w_dotp); |
| while (--n) { |
| if (nextp == curbp->b_linep) |
| return FALSE; |
| chunk += llength(nextp) + 1; |
| nextp = lforw(nextp); |
| } |
| } else { |
| mlwrite("neg kill"); |
| return FALSE; |
| } |
| return ldelete(chunk, TRUE); |
| } |
| |
| /* |
| * prompt and set an editor mode |
| * |
| * int f, n; default and argument |
| */ |
| int setemode(int f, int n) |
| { |
| #if PKCODE |
| return adjustmode(TRUE, FALSE); |
| #else |
| adjustmode(TRUE, FALSE); |
| #endif |
| } |
| |
| /* |
| * prompt and delete an editor mode |
| * |
| * int f, n; default and argument |
| */ |
| int delmode(int f, int n) |
| { |
| #if PKCODE |
| return adjustmode(FALSE, FALSE); |
| #else |
| adjustmode(FALSE, FALSE); |
| #endif |
| } |
| |
| /* |
| * prompt and set a global editor mode |
| * |
| * int f, n; default and argument |
| */ |
| int setgmode(int f, int n) |
| { |
| #if PKCODE |
| return adjustmode(TRUE, TRUE); |
| #else |
| adjustmode(TRUE, TRUE); |
| #endif |
| } |
| |
| /* |
| * prompt and delete a global editor mode |
| * |
| * int f, n; default and argument |
| */ |
| int delgmode(int f, int n) |
| { |
| #if PKCODE |
| return adjustmode(FALSE, TRUE); |
| #else |
| adjustmode(FALSE, TRUE); |
| #endif |
| } |
| |
| /* |
| * change the editor mode status |
| * |
| * int kind; true = set, false = delete |
| * int global; true = global flag, false = current buffer flag |
| */ |
| int adjustmode(int kind, int global) |
| { |
| char *scan; /* scanning pointer to convert prompt */ |
| int i; /* loop index */ |
| int status; /* error return on input */ |
| #if COLOR |
| int uflag; /* was modename uppercase? */ |
| #endif |
| char prompt[50]; /* string to prompt user with */ |
| char cbuf[NPAT]; /* buffer to recieve mode name into */ |
| |
| /* build the proper prompt string */ |
| if (global) |
| strcpy(prompt, "Global mode to "); |
| else |
| strcpy(prompt, "Mode to "); |
| |
| if (kind == TRUE) |
| strcat(prompt, "add: "); |
| else |
| strcat(prompt, "delete: "); |
| |
| /* prompt the user and get an answer */ |
| |
| status = mlreply(prompt, cbuf, NPAT - 1); |
| if (status != TRUE) |
| return status; |
| |
| /* make it uppercase */ |
| |
| scan = cbuf; |
| #if COLOR |
| uflag = (*scan >= 'A' && *scan <= 'Z'); |
| #endif |
| while (*scan != 0) { |
| if (*scan >= 'a' && *scan <= 'z') |
| *scan = *scan - 32; |
| scan++; |
| } |
| |
| /* test it first against the colors we know */ |
| #if PKCODE & IBMPC |
| for (i = 0; i <= NCOLORS; i++) { |
| #else |
| for (i = 0; i < NCOLORS; i++) { |
| #endif |
| if (strcmp(cbuf, cname[i]) == 0) { |
| /* finding the match, we set the color */ |
| #if COLOR |
| if (uflag) { |
| if (global) |
| gfcolor = i; |
| #if PKCODE == 0 |
| else |
| #endif |
| curwp->w_fcolor = i; |
| } else { |
| if (global) |
| gbcolor = i; |
| #if PKCODE == 0 |
| else |
| #endif |
| curwp->w_bcolor = i; |
| } |
| |
| curwp->w_flag |= WFCOLR; |
| #endif |
| mlerase(); |
| return TRUE; |
| } |
| } |
| |
| /* test it against the modes we know */ |
| |
| for (i = 0; i < NUMMODES; i++) { |
| if (strcmp(cbuf, modename[i]) == 0) { |
| /* finding a match, we process it */ |
| if (kind == TRUE) |
| if (global) |
| gmode |= (1 << i); |
| else |
| curbp->b_mode |= (1 << i); |
| else if (global) |
| gmode &= ~(1 << i); |
| else |
| curbp->b_mode &= ~(1 << i); |
| /* display new mode line */ |
| if (global == 0) |
| upmode(); |
| mlerase(); /* erase the junk */ |
| return TRUE; |
| } |
| } |
| |
| mlwrite("No such mode!"); |
| return FALSE; |
| } |
| |
| /* |
| * This function simply clears the message line, |
| * mainly for macro usage |
| * |
| * int f, n; arguments ignored |
| */ |
| int clrmes(int f, int n) |
| { |
| mlforce(""); |
| return TRUE; |
| } |
| |
| /* |
| * This function writes a string on the message line |
| * mainly for macro usage |
| * |
| * int f, n; arguments ignored |
| */ |
| int writemsg(int f, int n) |
| { |
| char *sp; /* pointer into buf to expand %s */ |
| char *np; /* ptr into nbuf */ |
| int status; |
| char buf[NPAT]; /* buffer to recieve message into */ |
| char nbuf[NPAT * 2]; /* buffer to expand string into */ |
| |
| if ((status = |
| mlreply("Message to write: ", buf, NPAT - 1)) != TRUE) |
| return status; |
| |
| /* expand all '%' to "%%" so mlwrite won't expect arguments */ |
| sp = buf; |
| np = nbuf; |
| while (*sp) { |
| *np++ = *sp; |
| if (*sp++ == '%') |
| *np++ = '%'; |
| } |
| *np = '\0'; |
| |
| /* write the message out */ |
| mlforce(nbuf); |
| return TRUE; |
| } |
| |
| #if CFENCE |
| /* |
| * the cursor is moved to a matching fence |
| * |
| * int f, n; not used |
| */ |
| int getfence(int f, int n) |
| { |
| struct line *oldlp; /* original line pointer */ |
| int oldoff; /* and offset */ |
| int sdir; /* direction of search (1/-1) */ |
| int count; /* current fence level count */ |
| char ch; /* fence type to match against */ |
| char ofence; /* open fence */ |
| char c; /* current character in scan */ |
| |
| /* save the original cursor position */ |
| oldlp = curwp->w_dotp; |
| oldoff = curwp->w_doto; |
| |
| /* get the current character */ |
| if (oldoff == llength(oldlp)) |
| ch = '\n'; |
| else |
| ch = lgetc(oldlp, oldoff); |
| |
| /* setup proper matching fence */ |
| switch (ch) { |
| case '(': |
| ofence = ')'; |
| sdir = FORWARD; |
| break; |
| case '{': |
| ofence = '}'; |
| sdir = FORWARD; |
| break; |
| case '[': |
| ofence = ']'; |
| sdir = FORWARD; |
| break; |
| case ')': |
| ofence = '('; |
| sdir = REVERSE; |
| break; |
| case '}': |
| ofence = '{'; |
| sdir = REVERSE; |
| break; |
| case ']': |
| ofence = '['; |
| sdir = REVERSE; |
| break; |
| default: |
| TTbeep(); |
| return FALSE; |
| } |
| |
| /* set up for scan */ |
| count = 1; |
| if (sdir == REVERSE) |
| backchar(FALSE, 1); |
| else |
| forwchar(FALSE, 1); |
| |
| /* scan until we find it, or reach the end of file */ |
| while (count > 0) { |
| if (curwp->w_doto == llength(curwp->w_dotp)) |
| c = '\n'; |
| else |
| c = lgetc(curwp->w_dotp, curwp->w_doto); |
| if (c == ch) |
| ++count; |
| if (c == ofence) |
| --count; |
| if (sdir == FORWARD) |
| forwchar(FALSE, 1); |
| else |
| backchar(FALSE, 1); |
| if (boundry(curwp->w_dotp, curwp->w_doto, sdir)) |
| break; |
| } |
| |
| /* if count is zero, we have a match, move the sucker */ |
| if (count == 0) { |
| if (sdir == FORWARD) |
| backchar(FALSE, 1); |
| else |
| forwchar(FALSE, 1); |
| curwp->w_flag |= WFMOVE; |
| return TRUE; |
| } |
| |
| /* restore the current position */ |
| curwp->w_dotp = oldlp; |
| curwp->w_doto = oldoff; |
| TTbeep(); |
| return FALSE; |
| } |
| #endif |
| |
| /* |
| * Close fences are matched against their partners, and if |
| * on screen the cursor briefly lights there |
| * |
| * char ch; fence type to match against |
| */ |
| int fmatch(int ch) |
| { |
| struct line *oldlp; /* original line pointer */ |
| int oldoff; /* and offset */ |
| struct line *toplp; /* top line in current window */ |
| int count; /* current fence level count */ |
| char opench; /* open fence */ |
| char c; /* current character in scan */ |
| int i; |
| |
| /* first get the display update out there */ |
| update(FALSE); |
| |
| /* save the original cursor position */ |
| oldlp = curwp->w_dotp; |
| oldoff = curwp->w_doto; |
| |
| /* setup proper open fence for passed close fence */ |
| if (ch == ')') |
| opench = '('; |
| else if (ch == '}') |
| opench = '{'; |
| else |
| opench = '['; |
| |
| /* find the top line and set up for scan */ |
| toplp = curwp->w_linep->l_bp; |
| count = 1; |
| backchar(FALSE, 2); |
| |
| /* scan back until we find it, or reach past the top of the window */ |
| while (count > 0 && curwp->w_dotp != toplp) { |
| if (curwp->w_doto == llength(curwp->w_dotp)) |
| c = '\n'; |
| else |
| c = lgetc(curwp->w_dotp, curwp->w_doto); |
| if (c == ch) |
| ++count; |
| if (c == opench) |
| --count; |
| backchar(FALSE, 1); |
| if (curwp->w_dotp == curwp->w_bufp->b_linep->l_fp && |
| curwp->w_doto == 0) |
| break; |
| } |
| |
| /* if count is zero, we have a match, display the sucker */ |
| /* there is a real machine dependant timing problem here we have |
| yet to solve......... */ |
| if (count == 0) { |
| forwchar(FALSE, 1); |
| for (i = 0; i < term.t_pause; i++) |
| update(FALSE); |
| } |
| |
| /* restore the current position */ |
| curwp->w_dotp = oldlp; |
| curwp->w_doto = oldoff; |
| return TRUE; |
| } |
| |
| /* |
| * ask for and insert a string into the current |
| * buffer at the current point |
| * |
| * int f, n; ignored arguments |
| */ |
| int istring(int f, int n) |
| { |
| int status; /* status return code */ |
| char tstring[NPAT + 1]; /* string to add */ |
| |
| /* ask for string to insert */ |
| status = |
| mlreplyt("String to insert<META>: ", tstring, NPAT, metac); |
| if (status != TRUE) |
| return status; |
| |
| if (f == FALSE) |
| n = 1; |
| |
| if (n < 0) |
| n = -n; |
| |
| /* insert it */ |
| while (n-- && (status = linstr(tstring))); |
| return status; |
| } |
| |
| /* |
| * ask for and overwite a string into the current |
| * buffer at the current point |
| * |
| * int f, n; ignored arguments |
| */ |
| int ovstring(int f, int n) |
| { |
| int status; /* status return code */ |
| char tstring[NPAT + 1]; /* string to add */ |
| |
| /* ask for string to insert */ |
| status = |
| mlreplyt("String to overwrite<META>: ", tstring, NPAT, metac); |
| if (status != TRUE) |
| return status; |
| |
| if (f == FALSE) |
| n = 1; |
| |
| if (n < 0) |
| n = -n; |
| |
| /* insert it */ |
| while (n-- && (status = lover(tstring))); |
| return status; |
| } |