home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume14 / jove4.9 / part01 / case.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-25  |  3.6 KB  |  229 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 "ctype.h"
  10.  
  11. #ifdef MAC
  12. #    undef private
  13. #    define private
  14. #endif
  15.  
  16. #ifdef    LINT_ARGS
  17. private    int
  18. #if !(defined(IBMPC) || defined(MAC))
  19.     lower(char *),
  20. #endif
  21.     upper(char *);
  22. #else
  23. private    int
  24. #if !(defined(IBMPC) || defined(MAC))
  25.     lower(),
  26. #endif
  27.     upper();
  28. #endif    /* LINT_ARGS */
  29.  
  30. #ifdef MAC
  31. #    undef private
  32. #    define private static
  33. #endif
  34.  
  35. void
  36. CapChar()
  37. {
  38.     register int    num,
  39.             restore = NO;
  40.     Bufpos    b;
  41.  
  42.     DOTsave(&b);
  43.  
  44.     num = arg_value();
  45.     if (num < 0) {
  46.         restore = YES;
  47.         num = -num;
  48.         b_char(num);    /* Cap previous EXP chars */
  49.     }
  50.     while (num--) {
  51.         if (upper(&linebuf[curchar])) {
  52.             modify();
  53.             makedirty(curline);
  54.         }
  55.         if (eolp()) {
  56.             if (curline->l_next == 0)
  57.                 break;
  58.             SetLine(curline->l_next);
  59.         } else
  60.             curchar += 1;
  61.     }
  62.     if (restore)
  63.         SetDot(&b);
  64. }
  65.  
  66. void
  67. CapWord()
  68. {
  69.     register int    num,
  70.             restore = NO;
  71.     Bufpos    b;
  72.  
  73.     DOTsave(&b);
  74.     num = arg_value();
  75.     if (num < 0) {
  76.         restore = YES;
  77.         num = -num;
  78.         b_word(num);        /* Cap previous EXP words */
  79.     }
  80.     while (num--) {
  81.         to_word(1);    /* Go to the beginning of the next word. */
  82.         if (eobp())
  83.             break;
  84.         if (upper(&linebuf[curchar])) {
  85.             modify();
  86.             makedirty(curline);
  87.         }
  88.         curchar += 1;
  89.         while (!eolp() && isword(linebuf[curchar])) {
  90.             if (lower(&linebuf[curchar])) {
  91.                 modify();
  92.                 makedirty(curline);
  93.             }
  94.             curchar += 1;
  95.         }
  96.     }
  97.     if (restore)
  98.         SetDot(&b);
  99. }
  100.  
  101. void
  102. case_word(up)
  103. {
  104.     Bufpos    before;
  105.  
  106.     DOTsave(&before);
  107.     ForWord();    /* this'll go backward if negative argument */
  108.     case_reg(before.p_line, before.p_char, curline, curchar, up);
  109. }
  110.  
  111. private int
  112. upper(c)
  113. register char    *c;
  114. {
  115.     if (islower(*c)) {
  116. #ifndef ASCII            /* check for IBM extended character set */
  117.         if (*c <= 127)
  118. #endif /* ASCII */
  119.         *c -= ' ';
  120. #ifdef IBMPC            /* ... and change Umlaute    */
  121.         else 
  122.            switch (*c) {
  123.              case 129: *c = 154; break;        /* ue */
  124.              case 132: *c = 142; break;        /* ae */
  125.              case 148: *c = 153; break;        /* oe */
  126.            }
  127. #endif /* IBMPC */
  128. #ifdef MAC
  129.         else *c = CaseEquiv[*c];
  130. #endif
  131.         return 1;
  132.     }
  133.     return 0;
  134. }
  135.  
  136. #if !(defined(IBMPC) || defined(MAC))
  137. private
  138. #endif
  139. int
  140. lower(c)
  141. char    *c;
  142. {
  143.     if (isupper(*c)) {
  144. #ifndef ASCII
  145.         if (*c <= 127) 
  146. #endif /* ASCII */
  147.         *c += ' ';
  148. #ifdef IBMPC
  149.         else
  150.               switch (*c) {
  151.              case 142: *c = 132; break;        /* Ae */
  152.              case 153: *c = 148; break;        /* Oe */
  153.              case 154: *c = 129; break;        /* Ue */
  154.            }
  155. #endif /* IBMPC */
  156. #ifdef MAC
  157.         else {
  158.             int n;
  159.             
  160.             for(n = 128; n < 256; n++) {
  161.                 if((CaseEquiv[n] == *c) && islower(n)) {
  162.                     *c = n;
  163.                     break;
  164.                 }
  165.             }
  166.             if(n > 255) return(0);
  167.         }
  168. #endif /* MAC */        
  169.         return 1;
  170.     }
  171.     return 0;
  172. }
  173.  
  174. void
  175. case_reg(line1, char1, line2, char2, up)
  176. Line    *line1,
  177.     *line2;
  178. int    char1;
  179. {
  180.     (void) fixorder(&line1, &char1, &line2, &char2);
  181.     DotTo(line1, char1);
  182.  
  183.     for (;;) {
  184.         if (curline == line2 && curchar == char2)
  185.             break;
  186.         if (!eolp())
  187.             if ((up) ? upper(&linebuf[curchar]) : lower(&linebuf[curchar])) {
  188.                 makedirty(curline);
  189.                 modify();
  190.             }
  191.         f_char(1);
  192.     }
  193. }
  194.  
  195. void
  196. CasRegLower()
  197. {
  198.     CaseReg(0);
  199. }
  200.  
  201. void
  202. CasRegUpper()
  203. {
  204.     CaseReg(1);
  205. }
  206.  
  207. void
  208. CaseReg(up)
  209. {
  210.     register Mark    *mp = CurMark();
  211.     Bufpos    savedot;
  212.  
  213.     DOTsave(&savedot);
  214.     case_reg(curline, curchar, mp->m_line, mp->m_char, up);
  215.     SetDot(&savedot);
  216. }
  217.  
  218. void
  219. UppWord()
  220. {
  221.     case_word(1);
  222. }
  223.  
  224. void
  225. LowWord()
  226. {
  227.     case_word(0);
  228. }
  229.