home *** CD-ROM | disk | FTP | other *** search
/ Carousel Volume 2 #1 / carousel.iso / mactosh / code / microema.sit / src / word.c < prev   
Encoding:
C/C++ Source or Header  |  1989-06-09  |  13.4 KB  |  558 lines  |  [TEXT/Earl]
  1. /*
  2.  * The routines in this file implement commands that work word or a
  3.  * paragraph at a time.  There are all sorts of word mode commands.  If I
  4.  * do any sentence mode commands, they are likely to be put in this file.
  5.  */
  6.  
  7. #include    <stdio.h>
  8. #include    "estruct.h"
  9. #include    "edef.h"
  10.  
  11. /* Word wrap on n-spaces. Back-over whatever precedes the point on the current
  12.  * line and stop on the first word-break or the beginning of the line. If we
  13.  * reach the beginning of the line, jump back to the end of the word and start
  14.  * a new line.    Otherwise, break the line at the word-break, eat it, and jump
  15.  * back to the end of the word.
  16.  * Returns TRUE on success, FALSE on errors.
  17.  */
  18. wrapword(f, n)
  19.  
  20. int f;        /* default flag */
  21. int n;        /* numeric argument */
  22.  
  23. {
  24.     register int cnt;    /* size of word wrapped to next line */
  25.     register int c;     /* charector temporary */
  26.  
  27.     /* backup from the <NL> 1 char */
  28.     if (!backchar(0, 1))
  29.         return(FALSE);
  30.  
  31.     /* back up until we aren't in a word,
  32.        make sure there is a break in the line */
  33.     cnt = 0;
  34.     while (((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ')
  35.                 && (c != '\t')) {
  36.         cnt++;
  37.         if (!backchar(0, 1))
  38.             return(FALSE);
  39.         /* if we make it to the beginning, start a new line */
  40.         if (curwp->w_doto == 0) {
  41.             gotoeol(FALSE, 0);
  42.             return(lnewline());
  43.         }
  44.     }
  45.  
  46.     /* delete the forward white space */
  47.     if (!forwdel(0, 1))
  48.         return(FALSE);
  49.  
  50.     /* put in a end of line */
  51.     if (!lnewline())
  52.         return(FALSE);
  53.  
  54.     /* and past the first word */
  55.     while (cnt-- > 0) {
  56.         if (forwchar(FALSE, 1) == FALSE)
  57.             return(FALSE);
  58.     }
  59.     return(TRUE);
  60. }
  61.  
  62. /*
  63.  * Move the cursor backward by "n" words. All of the details of motion are
  64.  * performed by the "backchar" and "forwchar" routines. Error if you try to
  65.  * move beyond the buffers.
  66.  */
  67. backword(f, n)
  68. {
  69.     if (n < 0)
  70.         return (forwword(f, -n));
  71.     if (backchar(FALSE, 1) == FALSE)
  72.         return (FALSE);
  73.     while (n--) {
  74.         while (inword() == FALSE) {
  75.             if (backchar(FALSE, 1) == FALSE)
  76.                 return (FALSE);
  77.         }
  78.         while (inword() != FALSE) {
  79.             if (backchar(FALSE, 1) == FALSE)
  80.                 return (FALSE);
  81.         }
  82.     }
  83.     return (forwchar(FALSE, 1));
  84. }
  85.  
  86. /*
  87.  * Move the cursor forward by the specified number of words. All of the motion
  88.  * is done by "forwchar". Error if you try and move beyond the buffer's end.
  89.  */
  90. forwword(f, n)
  91. {
  92.     if (n < 0)
  93.         return (backword(f, -n));
  94.     while (n--) {
  95.         while (inword() == TRUE) {
  96.             if (forwchar(FALSE, 1) == FALSE)
  97.                 return (FALSE);
  98.         }
  99.  
  100.         while (inword() == FALSE) {
  101.             if (forwchar(FALSE, 1) == FALSE)
  102.                 return (FALSE);
  103.         }
  104.     }
  105.     return(TRUE);
  106. }
  107.  
  108. /*
  109.  * Move the cursor forward by the specified number of words. As you move,
  110.  * convert any characters to upper case. Error if you try and move beyond the
  111.  * end of the buffer. Bound to "M-U".
  112.  */
  113. upperword(f, n)
  114. {
  115.     register int    c;
  116.  
  117.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if  */
  118.         return(rdonly());    /* we are in read only mode    */
  119.     if (n < 0)
  120.         return (FALSE);
  121.     while (n--) {
  122.         while (inword() == FALSE) {
  123.             if (forwchar(FALSE, 1) == FALSE)
  124.                 return (FALSE);
  125.         }
  126.         while (inword() != FALSE) {
  127.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  128.             if (c>='a' && c<='z') {
  129.                 c -= 'a'-'A';
  130.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  131.                 lchange(WFHARD);
  132.             }
  133.             if (forwchar(FALSE, 1) == FALSE)
  134.                 return (FALSE);
  135.         }
  136.     }
  137.     return (TRUE);
  138. }
  139.  
  140. /*
  141.  * Move the cursor forward by the specified number of words. As you move
  142.  * convert characters to lower case. Error if you try and move over the end of
  143.  * the buffer. Bound to "M-L".
  144.  */
  145. lowerword(f, n)
  146. {
  147.     register int    c;
  148.  
  149.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if  */
  150.         return(rdonly());    /* we are in read only mode    */
  151.     if (n < 0)
  152.         return (FALSE);
  153.     while (n--) {
  154.         while (inword() == FALSE) {
  155.             if (forwchar(FALSE, 1) == FALSE)
  156.                 return (FALSE);
  157.         }
  158.         while (inword() != FALSE) {
  159.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  160.             if (c>='A' && c<='Z') {
  161.                 c += 'a'-'A';
  162.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  163.                 lchange(WFHARD);
  164.             }
  165.             if (forwchar(FALSE, 1) == FALSE)
  166.                 return (FALSE);
  167.         }
  168.     }
  169.     return (TRUE);
  170. }
  171.  
  172. /*
  173.  * Move the cursor forward by the specified number of words. As you move
  174.  * convert the first character of the word to upper case, and subsequent
  175.  * characters to lower case. Error if you try and move past the end of the
  176.  * buffer. Bound to "M-C".
  177.  */
  178. capword(f, n)
  179. {
  180.     register int    c;
  181.  
  182.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if  */
  183.         return(rdonly());    /* we are in read only mode    */
  184.     if (n < 0)
  185.         return (FALSE);
  186.     while (n--) {
  187.         while (inword() == FALSE) {
  188.             if (forwchar(FALSE, 1) == FALSE)
  189.                 return (FALSE);
  190.         }
  191.         if (inword() != FALSE) {
  192.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  193.             if (c>='a' && c<='z') {
  194.                 c -= 'a'-'A';
  195.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  196.                 lchange(WFHARD);
  197.             }
  198.             if (forwchar(FALSE, 1) == FALSE)
  199.                 return (FALSE);
  200.             while (inword() != FALSE) {
  201.                 c = lgetc(curwp->w_dotp, curwp->w_doto);
  202.                 if (c>='A' && c<='Z') {
  203.                     c += 'a'-'A';
  204.                     lputc(curwp->w_dotp, curwp->w_doto, c);
  205.                     lchange(WFHARD);
  206.                 }
  207.                 if (forwchar(FALSE, 1) == FALSE)
  208.                     return (FALSE);
  209.             }
  210.         }
  211.     }
  212.     return (TRUE);
  213. }
  214.  
  215. /*
  216.  * Kill forward by "n" words. Remember the location of dot. Move forward by
  217.  * the right number of words. Put dot back where it was and issue the kill
  218.  * command for the right number of characters. With a zero argument, just
  219.  * kill one word and no whitespace. Bound to "M-D".
  220.  */
  221. delfword(f, n)
  222. {
  223.     register LINE    *dotp;    /* original cursor line */
  224.     register int    doto;    /*    and row */
  225.     register int c;     /* temp char */
  226.     long size;        /* # of chars to delete */
  227.  
  228.     /* don't allow this command if we are in read only mode */
  229.     if (curbp->b_mode&MDVIEW)
  230.         return(rdonly());
  231.  
  232.     /* ignore the command if there is a negative argument */
  233.     if (n < 0)
  234.         return (FALSE);
  235.  
  236.     /* Clear the kill buffer if last command wasn't a kill */
  237.     if ((lastflag&CFKILL) == 0)
  238.         kdelete();
  239.     thisflag |= CFKILL;    /* this command is a kill */
  240.  
  241.     /* save the current cursor position */
  242.     dotp = curwp->w_dotp;
  243.     doto = curwp->w_doto;
  244.  
  245.     /* figure out how many characters to give the axe */
  246.     size = 0;
  247.  
  248.     /* get us into a word.... */
  249.     while (inword() == FALSE) {
  250.         if (forwchar(FALSE, 1) == FALSE)
  251.             return(FALSE);
  252.         ++size;
  253.     }
  254.  
  255.     if (n == 0) {
  256.         /* skip one word, no whitespace! */
  257.         while (inword() == TRUE) {
  258.             if (forwchar(FALSE, 1) == FALSE)
  259.                 return(FALSE);
  260.             ++size;
  261.         }
  262.     } else {
  263.         /* skip n words.... */
  264.         while (n--) {
  265.     
  266.             /* if we are at EOL; skip to the beginning of the next */
  267.             while (curwp->w_doto == llength(curwp->w_dotp)) {
  268.                 if (forwchar(FALSE, 1) == FALSE)
  269.                     return(FALSE);
  270.                 ++size;
  271.             }
  272.     
  273.             /* move forward till we are at the end of the word */
  274.             while (inword() == TRUE) {
  275.                 if (forwchar(FALSE, 1) == FALSE)
  276.                     return(FALSE);
  277.                 ++size;
  278.             }
  279.     
  280.             /* if there are more words, skip the interword stuff */
  281.             if (n != 0)
  282.                 while (inword() == FALSE) {
  283.                     if (forwchar(FALSE, 1) == FALSE)
  284.                         return(FALSE);
  285.                     ++size;
  286.                 }
  287.         }
  288.     
  289.         /* skip whitespace and newlines */
  290.         while ((curwp->w_doto == llength(curwp->w_dotp)) ||
  291.             ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ') ||
  292.             (c == '\t')) {
  293.                 if (forwchar(FALSE, 1) == FALSE)
  294.                     break;
  295.                 ++size;
  296.         }
  297.     }
  298.  
  299.     /* restore the original position and delete the words */
  300.     curwp->w_dotp = dotp;
  301.     curwp->w_doto = doto;
  302.     return (ldelete(size, TRUE));
  303. }
  304.  
  305. /*
  306.  * Kill backwards by "n" words. Move backwards by the desired number of words,
  307.  * counting the characters. When dot is finally moved to its resting place,
  308.  * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace".
  309.  */
  310. delbword(f, n)
  311. {
  312.     long size;
  313.  
  314.     /* don't allow this command if we are in read only mode */
  315.     if (curbp->b_mode&MDVIEW)
  316.         return(rdonly());
  317.  
  318.     /* ignore the command if there is a nonpositive argument */
  319.     if (n <= 0)
  320.         return (FALSE);
  321.  
  322.     /* Clear the kill buffer if last command wasn't a kill */
  323.     if ((lastflag&CFKILL) == 0)
  324.         kdelete();
  325.     thisflag |= CFKILL;    /* this command is a kill */
  326.  
  327.     if (backchar(FALSE, 1) == FALSE)
  328.         return (FALSE);
  329.     size = 0;
  330.     while (n--) {
  331.         while (inword() == FALSE) {
  332.             if (backchar(FALSE, 1) == FALSE)
  333.                 return (FALSE);
  334.             ++size;
  335.         }
  336.         while (inword() != FALSE) {
  337.             ++size;
  338.             if (backchar(FALSE, 1) == FALSE)
  339.                 goto bckdel;
  340.         }
  341.     }
  342.     if (forwchar(FALSE, 1) == FALSE)
  343.         return (FALSE);
  344. bckdel: return (ldelete(size, TRUE));
  345. }
  346.  
  347. /*
  348.  * Return TRUE if the character at dot is a character that is considered to be
  349.  * part of a word. The word character list is hard coded. Should be setable.
  350.  */
  351. inword()
  352. {
  353.     register int    c;
  354.  
  355.     if (curwp->w_doto == llength(curwp->w_dotp))
  356.         return (FALSE);
  357.     c = lgetc(curwp->w_dotp, curwp->w_doto);
  358.     if (c>='a' && c<='z' || c>='A' && c<='Z' || c>='0' && c<='9'
  359.         || c == '_')
  360.         return (TRUE);
  361.     return (FALSE);
  362. }
  363.  
  364. #if    WORDPRO
  365. fillpara(f, n)    /* Fill the current paragraph according to the current
  366.            fill column                        */
  367.  
  368. int f, n;    /* deFault flag and Numeric argument */
  369.  
  370. {
  371.     register int c;         /* current char durring scan    */
  372.     register int wordlen;        /* length of current word    */
  373.     register int clength;        /* position on line during fill */
  374.     register int i;         /* index during word copy    */
  375.     register int newlength;     /* tentative new line length    */
  376.     register int eopflag;        /* Are we at the End-Of-Paragraph? */
  377.     register int firstflag;     /* first word? (needs no space) */
  378.     register LINE *eopline;     /* pointer to line just past EOP */
  379.     register int dotflag;        /* was the last char a period?    */
  380.     char wbuf[NSTRING];        /* buffer for current word    */
  381.  
  382.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if  */
  383.         return(rdonly());    /* we are in read only mode    */
  384.     if (fillcol == 0) {    /* no fill column set */
  385.         mlwrite("No fill column set");
  386.         return(FALSE);
  387.     }
  388.  
  389.     /* record the pointer to the line just past the EOP */
  390.     gotoeop(FALSE, 1);
  391.     eopline = lforw(curwp->w_dotp);
  392.  
  393.     /* and back top the beginning of the paragraph */
  394.     gotobop(FALSE, 1);
  395.  
  396.     /* initialize various info */
  397.     clength = curwp->w_doto;
  398.     if (clength && lgetc(curwp->w_dotp,0) == TAB)
  399.         clength = tabstops;
  400.     wordlen = 0;
  401.     dotflag = FALSE;
  402.  
  403.     /* scan through lines, filling words */
  404.     firstflag = TRUE;
  405.     eopflag = FALSE;
  406.     while (!eopflag) {
  407.         /* get the next character in the paragraph */
  408.         if (curwp->w_doto == llength(curwp->w_dotp)) {
  409.             c = ' ';
  410.             if (lforw(curwp->w_dotp) == eopline)
  411.                 eopflag = TRUE;
  412.         } else
  413.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  414.  
  415.         /* and then delete it */
  416.         ldelete(1L, FALSE);
  417.  
  418.         /* if not a separator, just add it in */
  419.         if (c != ' ' && c != '\t') {
  420.             dotflag = (c == '.');        /* was it a dot */
  421.             if (wordlen < NSTRING - 1)
  422.                 wbuf[wordlen++] = c;
  423.         } else if (wordlen) {
  424.             /* at a word break with a word waiting */
  425.             /* calculate tentitive new length with word added */
  426.             newlength = clength + 1 + wordlen;
  427.             if (newlength <= fillcol) {
  428.                 /* add word to current line */
  429.                 if (!firstflag) {
  430.                     linsert(1, ' '); /* the space */
  431.                     ++clength;
  432.                 }
  433.                 firstflag = FALSE;
  434.             } else {
  435.                 /* start a new line */
  436.                 lnewline();
  437.                 clength = 0;
  438.             }
  439.  
  440.             /* and add the word in in either case */
  441.             for (i=0; i<wordlen; i++) {
  442.                 linsert(1, wbuf[i]);
  443.                 ++clength;
  444.             }
  445.             if (dotflag) {
  446.                 linsert(1, ' ');
  447.                 ++clength;
  448.             }
  449.             wordlen = 0;
  450.         }
  451.     }
  452.     /* and add a last newline for the end of our new paragraph */
  453.     lnewline();
  454.     return(TRUE);
  455. }
  456.  
  457. killpara(f, n)    /* delete n paragraphs starting with the current one */
  458.  
  459. int f;    /* default flag */
  460. int n;    /* # of paras to delete */
  461.  
  462. {
  463.     register int status;    /* returned status of functions */
  464.  
  465.     while (n--) {        /* for each paragraph to delete */
  466.  
  467.         /* mark out the end and beginning of the para to delete */
  468.         gotoeop(FALSE, 1);
  469.  
  470.         /* set the mark here */
  471.         curwp->w_markp = curwp->w_dotp;
  472.         curwp->w_marko = curwp->w_doto;
  473.  
  474.         /* go to the beginning of the paragraph */
  475.         gotobop(FALSE, 1);
  476.         curwp->w_doto = 0;    /* force us to the beginning of line */
  477.     
  478.         /* and delete it */
  479.         if ((status = killregion(FALSE, 1)) != TRUE)
  480.             return(status);
  481.  
  482.         /* and clean up the 2 extra lines */
  483.         ldelete(2L, TRUE);
  484.     }
  485.     return(TRUE);
  486. }
  487.  
  488.  
  489. /*    wordcount:    count the # of words in the marked region,
  490.             along with average word sizes, # of chars, etc,
  491.             and report on them.            */
  492.  
  493. wordcount(f, n)
  494.  
  495. int f, n;    /* ignored numeric arguments */
  496.  
  497. {
  498.     register LINE *lp;    /* current line to scan */
  499.     register int offset;    /* current char to scan */
  500.     long size;        /* size of region left to count */
  501.     register int ch;    /* current character to scan */
  502.     register int wordflag;    /* are we in a word now? */
  503.     register int lastword;    /* were we just in a word? */
  504.     long nwords;        /* total # of words */
  505.     long nchars;        /* total number of chars */
  506.     int nlines;        /* total number of lines in region */
  507.     int avgch;        /* average number of chars/word */
  508.     int status;        /* status return code */
  509.     REGION region;        /* region to look at */
  510.  
  511.     /* make sure we have a region to count */
  512.     if ((status = getregion(®ion)) != TRUE)
  513.         return(status);
  514.     lp = region.r_linep;
  515.     offset = region.r_offset;
  516.     size = region.r_size;
  517.  
  518.     /* count up things */
  519.     lastword = FALSE;
  520.     nchars = 0L;
  521.     nwords = 0L;
  522.     nlines = 0;
  523.     while (size--) {
  524.  
  525.         /* get the current character */
  526.         if (offset == llength(lp)) {    /* end of line */
  527.             ch = EOLCHAR;
  528.             lp = lforw(lp);
  529.             offset = 0;
  530.             ++nlines;
  531.         } else {
  532.             ch = lgetc(lp, offset);
  533.             ++offset;
  534.         }
  535.  
  536.         /* and tabulate it */
  537.         wordflag = ((ch >= 'a' && ch <= 'z') ||
  538.                 (ch >= 'A' && ch <= 'Z') ||
  539.                 (ch >= '0' && ch <= '9') ||
  540.                 (ch == '_'));
  541.         if (wordflag == TRUE && lastword == FALSE)
  542.             ++nwords;
  543.         lastword = wordflag;
  544.         ++nchars;
  545.     }
  546.  
  547.     /* and report on the info */
  548.     if (nwords > 0L)
  549.         avgch = (int)((100L * nchars) / nwords);
  550.     else
  551.         avgch = 0;
  552.  
  553.     mlwrite("Words %D Chars %D Lines %d Avg chars/word %f",
  554.         nwords, nchars, nlines + 1, avgch);
  555.     return(TRUE);
  556. }
  557. #endif
  558.