word.c

/*	word.c
 *
 *      The routines in this file implement commands that work word or a
 *      paragraph at a time.  There are all sorts of word mode commands.  If I
 *      do any sentence mode commands, they are likely to be put in this file.
 *
 *	Modified by Petri Kutvonen
 */

#include <stdio.h>

#include "estruct.h"
#include "edef.h"
#include "efunc.h"
#include "line.h"

/* Word wrap on n-spaces. Back-over whatever precedes the point on the current
 * line and stop on the first word-break or the beginning of the line. If we
 * reach the beginning of the line, jump back to the end of the word and start
 * a new line.	Otherwise, break the line at the word-break, eat it, and jump
 * back to the end of the word.
 * Returns TRUE on success, FALSE on errors.
 *
 * @f: default flag.
 * @n: numeric argument.
 */
int wrapword(int f, int n) {
  int cnt;    /* size of word wrapped to next line */
  int c;        /* charector temporary */

  /* backup from the <NL> 1 char */
  if (!backchar(0, 1))
    return FALSE;

  /* back up until we aren't in a word,
     make sure there is a break in the line */
  cnt = 0;
  while (((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ')
      && (c != '\t')) {
    cnt++;
    if (!backchar(0, 1))
      return FALSE;
    /* if we make it to the beginning, start a new line */
    if (curwp->w_doto == 0) {
      gotoeol(FALSE, 0);
      return lnewline();
    }
  }

  /* delete the forward white space */
  if (!forwdel(0, 1))
    return FALSE;

  /* put in a end of line */
  if (!lnewline())
    return FALSE;

  /* and past the first word */
  while (cnt-- > 0) {
    if (forwchar(FALSE, 1) == FALSE)
      return FALSE;
  }
  return TRUE;
}

/*
 * Move the cursor backward by "n" words. All of the details of motion are
 * performed by the "backchar" and "forwchar" routines. Error if you try to
 * move beyond the buffers.
 */
int backword(int f, int n) {
  if (n < 0)
    return forwword(f, -n);
  if (backchar(FALSE, 1) == FALSE)
    return FALSE;
  while (n--) {
    while (inword() == FALSE) {
      if (backchar(FALSE, 1) == FALSE)
        return FALSE;
    }
    while (inword() != FALSE) {
      if (backchar(FALSE, 1) == FALSE)
        return FALSE;
    }
  }
  return forwchar(FALSE, 1);
}

/*
 * Move the cursor forward by the specified number of words. All of the motion
 * is done by "forwchar". Error if you try and move beyond the buffer's end.
 */
int forwword(int f, int n) {
  if (n < 0)
    return backword(f, -n);
  while (n--) {
    while (inword() == TRUE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }

    while (inword() == FALSE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
  }
  return TRUE;
}

/*
 * Move the cursor forward by the specified number of words. As you move,
 * convert any characters to upper case. Error if you try and move beyond the
 * end of the buffer. Bound to "M-U".
 */
int upperword(int f, int n) {
  int c;

  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--) {
    while (inword() == FALSE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
    while (inword() != FALSE) {
      c = lgetc(curwp->w_dotp, curwp->w_doto);
#if    PKCODE
      if (islower(c)) {
#else
        if (c >= 'a' && c <= 'z') {
#endif
        c -= 'a' - 'A';
        lputc(curwp->w_dotp, curwp->w_doto, c);
        lchange(WFHARD);
      }
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
  }
  return TRUE;
}

/*
 * Move the cursor forward by the specified number of words. As you move
 * convert characters to lower case. Error if you try and move over the end of
 * the buffer. Bound to "M-L".
 */
int lowerword(int f, int n) {
  int c;

  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--) {
    while (inword() == FALSE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
    while (inword() != FALSE) {
      c = lgetc(curwp->w_dotp, curwp->w_doto);
#if    PKCODE
      if (isupper(c)) {
#else
        if (c >= 'A' && c <= 'Z') {
#endif
        c += 'a' - 'A';
        lputc(curwp->w_dotp, curwp->w_doto, c);
        lchange(WFHARD);
      }
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
  }
  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 and move past the end of the
 * buffer. Bound to "M-C".
 */
int capword(int f, int n) {
  int c;

  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--) {
    while (inword() == FALSE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
    }
    if (inword() != FALSE) {
      c = lgetc(curwp->w_dotp, curwp->w_doto);
#if    PKCODE
      if (islower(c)) {
#else
        if (c >= 'a' && c <= 'z') {
#endif
        c -= 'a' - 'A';
        lputc(curwp->w_dotp, curwp->w_doto, c);
        lchange(WFHARD);
      }
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
      while (inword() != FALSE) {
        c = lgetc(curwp->w_dotp, curwp->w_doto);
#if    PKCODE
        if (isupper(c)) {
#else
          if (c >= 'A' && c <= 'Z') {
#endif
          c += 'a' - 'A';
          lputc(curwp->w_dotp, curwp->w_doto,
                c);
          lchange(WFHARD);
        }
        if (forwchar(FALSE, 1) == FALSE)
          return FALSE;
      }
    }
  }
  return TRUE;
}

/*
 * Kill forward by "n" words. Remember the location of dot. Move forward by
 * the right number of words. Put dot back where it was and issue the kill
 * command for the right number of characters. With a zero argument, just
 * kill one word and no whitespace. Bound to "M-D".
 */
int delfword(int f, int n) {
  struct line *dotp;    /* original cursor line */
  int doto;    /*      and row */
  int c;        /* temp char */
  long size;        /* # of chars to delete */

  /* don't allow this command if we are in read only mode */
  if (curbp->b_mode & MDVIEW)
    return rdonly();

  /* ignore the command if there is a negative argument */
  if (n < 0)
    return FALSE;

  /* Clear the kill buffer if last command wasn't a kill */
  if ((lastflag & CFKILL) == 0)
    kdelete();
  thisflag |= CFKILL;    /* this command is a kill */

  /* save the current cursor position */
  dotp = curwp->w_dotp;
  doto = curwp->w_doto;

  /* figure out how many characters to give the axe */
  size = 0;

  /* get us into a word.... */
  while (inword() == FALSE) {
    if (forwchar(FALSE, 1) == FALSE)
      return FALSE;
    ++size;
  }

  if (n == 0) {
    /* skip one word, no whitespace! */
    while (inword() == TRUE) {
      if (forwchar(FALSE, 1) == FALSE)
        return FALSE;
      ++size;
    }
  } else {
    /* skip n words.... */
    while (n--) {

      /* if we are at EOL; skip to the beginning of the next */
      while (curwp->w_doto == llength(curwp->w_dotp)) {
        if (forwchar(FALSE, 1) == FALSE)
          return FALSE;
        ++size;
      }

      /* move forward till we are at the end of the word */
      while (inword() == TRUE) {
        if (forwchar(FALSE, 1) == FALSE)
          return FALSE;
        ++size;
      }

      /* if there are more words, skip the interword stuff */
      if (n != 0)
        while (inword() == FALSE) {
          if (forwchar(FALSE, 1) == FALSE)
            return FALSE;
          ++size;
        }
    }

    /* skip whitespace and newlines */
    while ((curwp->w_doto == llength(curwp->w_dotp)) ||
        ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ')
        || (c == '\t')) {
      if (forwchar(FALSE, 1) == FALSE)
        break;
      ++size;
    }
  }

  /* restore the original position and delete the words */
  curwp->w_dotp = dotp;
  curwp->w_doto = doto;
  return ldelete(size, TRUE);
}

/*
 * Kill backwards by "n" words. Move backwards by the desired number of words,
 * counting the characters. When dot is finally moved to its resting place,
 * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace".
 */
int delbword(int f, int n) {
  long size;

  /* don't allow this command if we are in read only mode */
  if (curbp->b_mode & MDVIEW)
    return rdonly();

  /* ignore the command if there is a nonpositive argument */
  if (n <= 0)
    return FALSE;

  /* Clear the kill buffer if last command wasn't a kill */
  if ((lastflag & CFKILL) == 0)
    kdelete();
  thisflag |= CFKILL;    /* this command is a kill */

  if (backchar(FALSE, 1) == FALSE)
    return FALSE;
  size = 0;
  while (n--) {
    while (inword() == FALSE) {
      if (backchar(FALSE, 1) == FALSE)
        return FALSE;
      ++size;
    }
    while (inword() != FALSE) {
      ++size;
      if (backchar(FALSE, 1) == FALSE)
        goto bckdel;
    }
  }
  if (forwchar(FALSE, 1) == FALSE)
    return FALSE;
  bckdel:
  return ldelchar(size, TRUE);
}

/*
 * 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 setable.
 */
int inword(void) {
  int c;

  if (curwp->w_doto == llength(curwp->w_dotp))
    return FALSE;
  c = lgetc(curwp->w_dotp, curwp->w_doto);
#if    PKCODE
  if (isletter(c))
#else
    if (c >= 'a' && c <= 'z')
        return TRUE;
    if (c >= 'A' && c <= 'Z')
#endif
    return TRUE;
  if (c >= '0' && c <= '9')
    return TRUE;
  return FALSE;
}

#if    WORDPRO
/*
 * Fill the current paragraph according to the current
 * fill column
 *
 * f and n - deFault flag and Numeric argument
 */
int fillpara(int f, int n) {
  unicode_t c;        /* current char during scan    */
  unicode_t wbuf[NSTRING];/* buffer for current word      */
  int wordlen;    /* length of current word       */
  int clength;    /* position on line during fill */
  int i;        /* index during word copy       */
  int newlength;    /* tentative new line length    */
  int eopflag;    /* Are we at the End-Of-Paragraph? */
  int firstflag;    /* first word? (needs no space) */
  struct line *eopline;    /* pointer to line just past EOP */
  int dotflag;    /* was the last char a period?  */

  if (curbp->b_mode & MDVIEW)    /* don't allow this command if      */
    return rdonly();    /* we are in read only mode     */
  if (fillcol == 0) {    /* no fill column set */
    mlwrite("No fill column set");
    return FALSE;
  }
#if    PKCODE
  justflag = FALSE;
#endif

  /* record the pointer to the line just past the EOP */
  gotoeop(FALSE, 1);
  eopline = lforw(curwp->w_dotp);

  /* and back top the beginning of the paragraph */
  gotobop(FALSE, 1);

  /* initialize various info */
  clength = curwp->w_doto;
  if (clength && curwp->w_dotp->l_text[0] == TAB)
    clength = 8;
  wordlen = 0;
  dotflag = FALSE;

  /* scan through lines, filling words */
  firstflag = TRUE;
  eopflag = FALSE;
  while (!eopflag) {
    int bytes = 1;

    /* get the next character in the paragraph */
    if (curwp->w_doto == llength(curwp->w_dotp)) {
      c = ' ';
      if (lforw(curwp->w_dotp) == eopline)
        eopflag = TRUE;
    } else
      bytes = lgetchar(&c);

    /* and then delete it */
    ldelete(bytes, FALSE);

    /* if not a separator, just add it in */
    if (c != ' ' && c != '\t') {
      dotflag = (c == '.');    /* was it a dot */
      if (wordlen < NSTRING - 1)
        wbuf[wordlen++] = c;
    } else if (wordlen) {
      /* at a word break with a word waiting */
      /* calculate tentitive new length with word added */
      newlength = clength + 1 + wordlen;
      if (newlength <= fillcol) {
        /* add word to current line */
        if (!firstflag) {
          linsert(1, ' ');    /* the space */
          ++clength;
        }
        firstflag = FALSE;
      } else {
        /* start a new line */
        lnewline();
        clength = 0;
      }

      /* and add the word in in either case */
      for (i = 0; i < wordlen; i++) {
        linsert(1, wbuf[i]);
        ++clength;
      }
      if (dotflag) {
        linsert(1, ' ');
        ++clength;
      }
      wordlen = 0;
    }
  }
  /* and add a last newline for the end of our new paragraph */
  lnewline();
  return TRUE;
}

#if    PKCODE
/* Fill the current paragraph according to the current
 * fill column and cursor position
 *
 * int f, n;		deFault flag and Numeric argument
 */
int justpara(int f, int n) {
  unicode_t c;        /* current char durring scan    */
  unicode_t wbuf[NSTRING];/* buffer for current word      */
  int wordlen;    /* length of current word       */
  int clength;    /* position on line during fill */
  int i;        /* index during word copy       */
  int newlength;    /* tentative new line length    */
  int eopflag;    /* Are we at the End-Of-Paragraph? */
  int firstflag;    /* first word? (needs no space) */
  struct line *eopline;    /* pointer to line just past EOP */
  int leftmarg;        /* left marginal */

  if (curbp->b_mode & MDVIEW)    /* don't allow this command if      */
    return rdonly();    /* we are in read only mode     */
  if (fillcol == 0) {    /* no fill column set */
    mlwrite("No fill column set");
    return FALSE;
  }
  justflag = TRUE;
  leftmarg = curwp->w_doto;
  if (leftmarg + 10 > fillcol) {
    mlwrite("Column too narrow");
    return FALSE;
  }

  /* record the pointer to the line just past the EOP */
  gotoeop(FALSE, 1);
  eopline = lforw(curwp->w_dotp);

  /* and back top the beginning of the paragraph */
  gotobop(FALSE, 1);

  /* initialize various info */
  if (leftmarg < llength(curwp->w_dotp))
    curwp->w_doto = leftmarg;

  clength = curwp->w_doto;
  if (clength && curwp->w_dotp->l_text[0] == TAB)
    clength = 8;

  wordlen = 0;

  /* scan through lines, filling words */
  firstflag = TRUE;
  eopflag = FALSE;
  while (!eopflag) {
    int bytes = 1;

    /* get the next character in the paragraph */
    if (curwp->w_doto == llength(curwp->w_dotp)) {
      c = ' ';
      if (lforw(curwp->w_dotp) == eopline)
        eopflag = TRUE;
    } else
      bytes = lgetchar(&c);

    /* and then delete it */
    ldelete(bytes, FALSE);

    /* if not a separator, just add it in */
    if (c != ' ' && c != '\t') {
      if (wordlen < NSTRING - 1)
        wbuf[wordlen++] = c;
    } else if (wordlen) {
      /* at a word break with a word waiting */
      /* calculate tentitive new length with word added */
      newlength = clength + 1 + wordlen;
      if (newlength <= fillcol) {
        /* add word to current line */
        if (!firstflag) {
          linsert(1, ' ');    /* the space */
          ++clength;
        }
        firstflag = FALSE;
      } else {
        /* start a new line */
        lnewline();
        for (i = 0; i < leftmarg; i++)
          linsert(1, ' ');
        clength = leftmarg;
      }

      /* and add the word in in either case */
      for (i = 0; i < wordlen; i++) {
        linsert(1, wbuf[i]);
        ++clength;
      }
      wordlen = 0;
    }
  }
  /* and add a last newline for the end of our new paragraph */
  lnewline();

  forwword(FALSE, 1);
  if (llength(curwp->w_dotp) > leftmarg)
    curwp->w_doto = leftmarg;
  else
    curwp->w_doto = llength(curwp->w_dotp);

  justflag = FALSE;
  return TRUE;
}
#endif

/*
 * delete n paragraphs starting with the current one
 *
 * int f	default flag
 * int n	# of paras to delete
 */
int killpara(int f, int n) {
  int status;    /* returned status of functions */

  while (n--) {        /* for each paragraph to delete */

    /* mark out the end and beginning of the para to delete */
    gotoeop(FALSE, 1);

    /* set the mark here */
    curwp->w_markp = curwp->w_dotp;
    curwp->w_marko = curwp->w_doto;

    /* go to the beginning of the paragraph */
    gotobop(FALSE, 1);
    curwp->w_doto = 0;    /* force us to the beginning of line */

    /* and delete it */
    if ((status = killregion(FALSE, 1)) != TRUE)
      return status;

    /* and clean up the 2 extra lines */
    ldelete(2L, TRUE);
  }
  return TRUE;
}

/*
 *	wordcount:	count the # of words in the marked region,
 *			along with average word sizes, # of chars, etc,
 *			and report on them.
 *
 * int f, n;		ignored numeric arguments
 */
int wordcount(int f, int n) {
  struct line *lp;    /* current line to scan */
  int offset;    /* current char to scan */
  long size;        /* size of region left to count */
  int ch;    /* current character to scan */
  int wordflag;    /* are we in a word now? */
  int lastword;    /* were we just in a word? */
  long nwords;        /* total # of words */
  long nchars;        /* total number of chars */
  int nlines;        /* total number of lines in region */
  int avgch;        /* average number of chars/word */
  int status;        /* status return code */
  struct region region;        /* region to look at */

  /* make sure we have a region to count */
  if ((status = getregion(&region)) != TRUE)
    return status;
  lp = region.r_linep;
  offset = region.r_offset;
  size = region.r_size;

  /* count up things */
  lastword = FALSE;
  nchars = 0L;
  nwords = 0L;
  nlines = 0;
  while (size--) {

    /* get the current character */
    if (offset == llength(lp)) {    /* end of line */
      ch = '\n';
      lp = lforw(lp);
      offset = 0;
      ++nlines;
    } else {
      ch = lgetc(lp, offset);
      ++offset;
    }

    /* and tabulate it */
    wordflag = (
#if    PKCODE
        (isletter(ch)) ||
#else
            (ch >= 'a' && ch <= 'z') ||
            (ch >= 'A' && ch <= 'Z') ||
#endif
            (ch >= '0' && ch <= '9'));
    if (wordflag == TRUE && lastword == FALSE)
      ++nwords;
    lastword = wordflag;
    ++nchars;
  }

  /* and report on the info */
  if (nwords > 0L)
    avgch = (int) ((100L * nchars) / nwords);
  else
    avgch = 0;

  mlwrite("Words %D Chars %D Lines %d Avg chars/word %f",
          nwords, nchars, nlines + 1, avgch);
  return TRUE;
}
#endif