Return to case.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove

Annotation of 43BSD/contrib/jove/case.c, revision 1.1.1.1

1.1       root        1: /*************************************************************************
                      2:  * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
                      3:  * provided to you without charge for use only on a licensed Unix        *
                      4:  * system.  You may copy JOVE provided that this notice is included with *
                      5:  * the copy.  You may not sell copies of this program or versions        *
                      6:  * modified for use on microcomputer systems, unless the copies are      *
                      7:  * included with a Unix system distribution and the source is provided.  *
                      8:  *************************************************************************/
                      9: 
                     10: #include "jove.h"
                     11: #include "ctype.h"
                     12: 
                     13: CapChar()
                     14: {
                     15:        register int    num,
                     16:                        restore = 0;
                     17:        Bufpos  b;
                     18: 
                     19:        DOTsave(&b);
                     20: 
                     21:        if (exp < 0) {
                     22:                restore++;
                     23:                exp = -exp;
                     24:                num = exp;
                     25:                BackChar();     /* Cap previous EXP chars */
                     26:        } else
                     27:                num = exp;
                     28:                
                     29:        exp = 1;        /* So all the commands are done once */
                     30: 
                     31:        while (num--) {
                     32:                if (upper(&linebuf[curchar])) {
                     33:                        modify();
                     34:                        makedirty(curline);
                     35:                }
                     36:                if (eolp()) {
                     37:                        if (curline->l_next == 0)
                     38:                                break;
                     39:                        SetLine(curline->l_next);
                     40:                }
                     41:                else
                     42:                        curchar++;
                     43:        }
                     44:        if (restore)
                     45:                SetDot(&b);
                     46: }
                     47: 
                     48: CapWord()
                     49: {
                     50:        register int    num,
                     51:                        restore = 0;
                     52:        Bufpos  b;
                     53: 
                     54:        DOTsave(&b);
                     55: 
                     56:        if (exp < 0) {
                     57:                restore++;
                     58:                exp = -exp;
                     59:                num = exp;
                     60:                BackWord();     /* Cap previous EXP words */
                     61:        } else
                     62:                num = exp;
                     63:                
                     64:        exp = 1;        /* So all the commands are done once */
                     65: 
                     66:        while (num--) {
                     67:                to_word(1);     /* Go to the beginning of the next word. */
                     68:                if (eobp())
                     69:                        break;
                     70:                if (upper(&linebuf[curchar])) {
                     71:                        modify();
                     72:                        makedirty(curline);
                     73:                }
                     74:                curchar++;
                     75:                while (!eolp() && isword(linebuf[curchar])) {
                     76:                        if (lower(&linebuf[curchar])) {
                     77:                                modify();
                     78:                                makedirty(curline);
                     79:                        }
                     80:                        curchar++;
                     81:                }
                     82:        }
                     83:        if (restore)
                     84:                SetDot(&b);
                     85: }
                     86: 
                     87: case_word(up)
                     88: {
                     89:        Bufpos  before;
                     90: 
                     91:        DOTsave(&before);
                     92:        ForWord();      /* This'll go backward if negative argument. */
                     93:        case_reg(before.p_line, before.p_char, curline, curchar, up);
                     94: }
                     95: 
                     96: static
                     97: upper(c)
                     98: register char  *c;
                     99: {
                    100:        if (islower(*c)) {
                    101:                *c -= ' ';
                    102:                return 1;
                    103:        }
                    104:        return 0;
                    105: }
                    106: 
                    107: static
                    108: lower(c)
                    109: register char  *c;
                    110: {
                    111:        if (isupper(*c)) {
                    112:                *c += ' ';
                    113:                return 1;
                    114:        }
                    115:        return 0;
                    116: }
                    117: 
                    118: case_reg(line1, char1, line2, char2, up)
                    119: Line   *line1,
                    120:        *line2;
                    121: int    char1;
                    122: {
                    123:        (void) fixorder(&line1, &char1, &line2, &char2);
                    124:        DotTo(line1, char1);
                    125: 
                    126:        exp = 1;
                    127:        for (;;) {
                    128:                if (curline == line2 && curchar == char2)
                    129:                        break;
                    130:                if (!eolp())
                    131:                        if ((up) ? upper(&linebuf[curchar]) : lower(&linebuf[curchar])) {
                    132:                                makedirty(curline);
                    133:                                modify();
                    134:                        }
                    135:                ForChar();
                    136:        }
                    137: }
                    138: 
                    139: CasRegLower()
                    140: {
                    141:        CaseReg(0);
                    142: }
                    143: 
                    144: CasRegUpper()
                    145: {
                    146:        CaseReg(1);
                    147: }
                    148: 
                    149: CaseReg(up)
                    150: {
                    151:        register Mark   *mp = CurMark();
                    152:        Bufpos  savedot;
                    153: 
                    154:        DOTsave(&savedot);
                    155:        case_reg(curline, curchar, mp->m_line, mp->m_char, up);
                    156:        SetDot(&savedot);
                    157: }
                    158: 
                    159: UppWord()
                    160: {
                    161:        case_word(1);
                    162: }
                    163: 
                    164: LowWord()
                    165: {
                    166:        case_word(0);
                    167: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.