Return to move3.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / vi

Annotation of coherent/g/usr/bin/vi/move3.c, revision 1.1.1.1

1.1       root        1: /* move3.c */
                      2: 
                      3: /* Author:
                      4:  *     Steve Kirkendall
                      5:  *     14407 SW Teal Blvd. #C
                      6:  *     Beaverton, OR 97005
                      7:  *     [email protected]
                      8:  */
                      9: 
                     10: 
                     11: /* This file contains movement functions that perform character searches */
                     12: 
                     13: #include "config.h"
                     14: #include "vi.h"
                     15: 
                     16: #ifndef NO_CHARSEARCH
                     17: static MARK    (*prevfwdfn)(); /* function to search in same direction */
                     18: static MARK    (*prevrevfn)(); /* function to search in opposite direction */
                     19: static char    prev_key;       /* sought cvhar from previous [fFtT] */
                     20: 
                     21: MARK   m__ch(m, cnt, cmd)
                     22:        MARK    m;      /* current position */
                     23:        long    cnt;
                     24:        int     cmd;    /* command: either ',' or ';' */
                     25: {
                     26:        MARK    (*tmp)();
                     27: 
                     28:        if (!prevfwdfn)
                     29:        {
                     30:                msg("No previous f, F, t, or T command");
                     31:                return MARK_UNSET;
                     32:        }
                     33: 
                     34:        if (cmd == ',')
                     35:        {
                     36:                m =  (*prevrevfn)(m, cnt, prev_key);
                     37: 
                     38:                /* Oops! we didn't want to change the prev*fn vars! */
                     39:                tmp = prevfwdfn;
                     40:                prevfwdfn = prevrevfn;
                     41:                prevrevfn = tmp;
                     42: 
                     43:                return m;
                     44:        }
                     45:        else
                     46:        {
                     47:                return (*prevfwdfn)(m, cnt, prev_key);
                     48:        }
                     49: }
                     50: 
                     51: /* move forward within this line to next occurrence of key */
                     52: MARK   m_fch(m, cnt, key)
                     53:        MARK    m;      /* where to search from */
                     54:        long    cnt;
                     55:        int     key;    /* what to search for */
                     56: {
                     57:        REG char        *text;
                     58: 
                     59:        DEFAULT(1);
                     60: 
                     61:        prevfwdfn = m_fch;
                     62:        prevrevfn = m_Fch;
                     63:        prev_key = key;
                     64: 
                     65:        pfetch(markline(m));
                     66:        text = ptext + markidx(m);
                     67:        while (cnt-- > 0)
                     68:        {
                     69:                do
                     70:                {
                     71:                        m++;
                     72:                        text++;
                     73:                } while (*text && *text != key);
                     74:        }
                     75:        if (!*text)
                     76:        {
                     77:                return MARK_UNSET;
                     78:        }
                     79:        return m;
                     80: }
                     81: 
                     82: /* move backward within this line to previous occurrence of key */
                     83: MARK   m_Fch(m, cnt, key)
                     84:        MARK    m;      /* where to search from */
                     85:        long    cnt;
                     86:        int     key;    /* what to search for */
                     87: {
                     88:        REG char        *text;
                     89: 
                     90:        DEFAULT(1);
                     91: 
                     92:        prevfwdfn = m_Fch;
                     93:        prevrevfn = m_fch;
                     94:        prev_key = key;
                     95: 
                     96:        pfetch(markline(m));
                     97:        text = ptext + markidx(m);
                     98:        while (cnt-- > 0)
                     99:        {
                    100:                do
                    101:                {
                    102:                        m--;
                    103:                        text--;
                    104:                } while (text >= ptext && *text != key);
                    105:        }
                    106:        if (text < ptext)
                    107:        {
                    108:                return MARK_UNSET;
                    109:        }
                    110:        return m;
                    111: }
                    112: 
                    113: /* move forward within this line almost to next occurrence of key */
                    114: MARK   m_tch(m, cnt, key)
                    115:        MARK    m;      /* where to search from */
                    116:        long    cnt;
                    117:        int     key;    /* what to search for */
                    118: {
                    119:        /* skip the adjacent char */
                    120:        pfetch(markline(m));
                    121:        if (plen <= markidx(m))
                    122:        {
                    123:                return MARK_UNSET;
                    124:        }
                    125:        m++;
                    126: 
                    127:        m = m_fch(m, cnt, key);
                    128:        if (m == MARK_UNSET)
                    129:        {
                    130:                return MARK_UNSET;
                    131:        }
                    132: 
                    133:        prevfwdfn = m_tch;
                    134:        prevrevfn = m_Tch;
                    135: 
                    136:        return m - 1;
                    137: }
                    138: 
                    139: /* move backward within this line almost to previous occurrence of key */
                    140: MARK   m_Tch(m, cnt, key)
                    141:        MARK    m;      /* where to search from */
                    142:        long    cnt;
                    143:        int     key;    /* what to search for */
                    144: {
                    145:        /* skip the adjacent char */
                    146:        if (markidx(m) == 0)
                    147:        {
                    148:                return MARK_UNSET;
                    149:        }
                    150:        m--;
                    151: 
                    152:        m = m_Fch(m, cnt, key);
                    153:        if (m == MARK_UNSET)
                    154:        {
                    155:                return MARK_UNSET;
                    156:        }
                    157: 
                    158:        prevfwdfn = m_Tch;
                    159:        prevrevfn = m_tch;
                    160: 
                    161:        return m + 1;
                    162: }
                    163: #endif

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