home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / src / baseline / jove-4.14.6.lha / jove-4.14.6 / case.c < prev    next >
C/C++ Source or Header  |  1992-01-10  |  4KB  |  225 lines
  1. /***************************************************************************
  2.  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
  3.  * is provided to you without charge, and with no warranty.  You may give  *
  4.  * away copies of JOVE, including sources, provided that this notice is    *
  5.  * included in all the files.                                              *
  6.  ***************************************************************************/
  7.  
  8. #include "jove.h"
  9. #include "disp.h"
  10. #include "ctype.h"
  11.  
  12. private    bool
  13.     lower proto((char *)),
  14.     upper proto((char *));
  15.  
  16. private void
  17.     CaseReg proto((bool up)),
  18.     case_reg proto((struct line *line1,int char1,struct line *line2,int char2,bool up));
  19.  
  20. void
  21. CapChar()
  22. {
  23.     register int    num,
  24.             restore = NO;
  25.     Bufpos    b;
  26.  
  27.     DOTsave(&b);
  28.  
  29.     num = arg_value();
  30.     if (num < 0) {
  31.         restore = YES;
  32.         num = -num;
  33.         b_char(num);    /* Cap previous EXP chars */
  34.     }
  35.     while (num--) {
  36.         if (upper(&linebuf[curchar])) {
  37.             modify();
  38.             makedirty(curline);
  39.         }
  40.         if (eolp()) {
  41.             if (curline->l_next == NULL)
  42.                 break;
  43.             SetLine(curline->l_next);
  44.         } else
  45.             curchar += 1;
  46.     }
  47.     if (restore)
  48.         SetDot(&b);
  49. }
  50.  
  51. void
  52. CapWord()
  53. {
  54.     register int    num,
  55.             restore = NO;
  56.     Bufpos    b;
  57.  
  58.     DOTsave(&b);
  59.     num = arg_value();
  60.     if (num < 0) {
  61.         restore = YES;
  62.         num = -num;
  63.         b_word(num);        /* Cap previous EXP words */
  64.     }
  65.     while (num--) {
  66.         to_word(1);    /* Go to the beginning of the next word. */
  67.         if (eobp())
  68.             break;
  69.         if (upper(&linebuf[curchar])) {
  70.             modify();
  71.             makedirty(curline);
  72.         }
  73.         curchar += 1;
  74.         while (!eolp() && jisword(linebuf[curchar])) {
  75.             if (lower(&linebuf[curchar])) {
  76.                 modify();
  77.                 makedirty(curline);
  78.             }
  79.             curchar += 1;
  80.         }
  81.     }
  82.     if (restore)
  83.         SetDot(&b);
  84. }
  85.  
  86. private void
  87. case_word(up)
  88. bool    up;
  89. {
  90.     Bufpos    before;
  91.  
  92.     DOTsave(&before);
  93.     ForWord();    /* this'll go backward if negative argument */
  94.     case_reg(before.p_line, before.p_char, curline, curchar, up);
  95. }
  96.  
  97. /* Convert *p to upper case.  Return TRUE iff it was changed. */
  98.  
  99. private bool
  100. upper(p)
  101. register char    *p;
  102. {
  103.     if (jislower(*p & CHARMASK)) {
  104.         *p = CharUpcase(*p & CHARMASK);
  105.         return YES;
  106.     }
  107.     return NO;
  108. }
  109.  
  110. /* Convert *p to lower case.  Return TRUE iff it was changed. */
  111.  
  112. private bool
  113. lower(p)
  114. char    *p;
  115. {
  116.     int c = *p & CHARMASK;
  117.  
  118.     if (jisupper(c)) {
  119. #ifdef    ASCII7
  120.         *p = jtolower(c);
  121. #else    /* !ASCII7 */
  122. #ifdef    IBMPC
  123.         if (c <= 127)
  124.             c += ' ';
  125.         else {
  126.             switch (c) {
  127.             case 142: c = 132; break;        /* Ae */
  128.             case 153: c = 148; break;        /* Oe */
  129.             case 154: c = 129; break;        /* Ue */
  130.             }
  131.         }
  132. #endif    /* IBMPC */
  133. #ifdef    MAC
  134.         if (c <= 127)
  135.             c += ' ';
  136.         else {
  137.             int n;
  138.  
  139.             for(n = 128; ; n++) {
  140.                 if (n > 255)
  141.                     return NO;
  142.                 if ((CharUpcase(n) == c) && jislower(n)) {
  143.                     c = n;
  144.                     break;
  145.                 }
  146.             }
  147.         }
  148. #endif    /* MAC */
  149.         *p = c;
  150. #endif    /* !ASCII7 */
  151.         return YES;
  152.     }
  153.     return NO;
  154. }
  155.  
  156. #ifndef    ASCII7
  157. char
  158. jtolower(c)
  159. char    c;
  160. {
  161.     if (jislower(c))
  162.     (void) lower(&c);
  163.     return c;
  164. }
  165. #endif    /*!ASCII7*/
  166.  
  167. private void
  168. case_reg(line1, char1, line2, char2, up)
  169. Line    *line1,
  170.     *line2;
  171. int    char1,
  172.     char2;
  173. bool    up;
  174. {
  175.     (void) fixorder(&line1, &char1, &line2, &char2);
  176.     DotTo(line1, char1);
  177.  
  178.     for (;;) {
  179.         if (curline == line2 && curchar == char2)
  180.             break;
  181.         if (!eolp())
  182.             if ((up) ? upper(&linebuf[curchar]) : lower(&linebuf[curchar])) {
  183.                 makedirty(curline);
  184.                 modify();
  185.             }
  186.         f_char(1);
  187.     }
  188. }
  189.  
  190. void
  191. CasRegLower()
  192. {
  193.     CaseReg(FALSE);
  194. }
  195.  
  196. void
  197. CasRegUpper()
  198. {
  199.     CaseReg(TRUE);
  200. }
  201.  
  202. private void
  203. CaseReg(up)
  204. bool    up;
  205. {
  206.     register Mark    *mp = CurMark();
  207.     Bufpos    savedot;
  208.  
  209.     DOTsave(&savedot);
  210.     case_reg(curline, curchar, mp->m_line, mp->m_char, up);
  211.     SetDot(&savedot);
  212. }
  213.  
  214. void
  215. UppWord()
  216. {
  217.     case_word(TRUE);
  218. }
  219.  
  220. void
  221. LowWord()
  222. {
  223.     case_word(FALSE);
  224. }
  225.