# 2.11BSD#431 - /usr/src/ucb/ex/ex_get.c

##### Functions

    checkjunk         X
    getach            X
    getcd             X
    getchar           X
    gettty            X
    ignchar           X
    peekcd            X
    peekchar          X
    setin             X
    smunch            X

##### Variables

    cntrlhm           X
    lastc             X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #if !defined(lint) && defined(DOSCCS)
       8: static char *sccsid = "@(#)ex_get.c	7.6 (Berkeley) 6/7/85";
       9: #endif
      10:
      11: #include "ex.h"
      12: #include "ex_tty.h"
      13:
      14: /*
      15:  * Input routines for command mode.
      16:  * Since we translate the end of reads into the implied ^D's
      17:  * we have different flavors of routines which do/don't return such.
      18:  */
      19: static  bool junkbs;
      20: short   lastc = '\n';
      21:
      22: ignchar()
      23: {
      24:     ignore(getchar());
      25: }
      26:
      27: getchar()
      28: {
      29:     register int c;
      30:
      31:     do
      32:         c = getcd();
      33:     while (!globp && c == CTRL(d));
      34:     return (c);
      35: }
      36:
      37: getcd()
      38: {
      39:     register int c;
      40:
      41: again:
      42:     c = getach();
      43:     if (c == EOF)
      44:         return (c);
      45:     c &= TRIM;
      46:     if (!inopen)
      47:         if (!globp && c == CTRL(d))
      48:             setlastchar('\n');
      49:         else if (junk(c)) {
      50:             checkjunk(c);
      51:             goto again;
      52:         }
      53:     return (c);
      54: }
      55:
      56: peekchar()
      57: {
      58:
      59:     if (peekc == 0)
      60:         peekc = getchar();
      61:     return (peekc);
      62: }
      63:
      64: peekcd()
      65: {
      66:     if (peekc == 0)
      67:         peekc = getcd();
      68:     return (peekc);
      69: }
      70:
      71: getach()
      72: {
      73:     register int c;
      74:     static char inline[BUFSIZ];
      75:     struct stat statb;
      76:
      77:     c = peekc;
      78:     if (c != 0) {
      79:         peekc = 0;
      80:         return (c);
      81:     }
      82:     if (globp) {
      83:         if (*globp)
      84:             return (*globp++);
      85:         globp = 0;
      86:         return (lastc = EOF);
      87:     }
      88: top:
      89:     if (input) {
      90:         if (c = *input++) {
      91:             if (c &= TRIM)
      92:                 return (lastc = c);
      93:             goto top;
      94:         }
      95:         input = 0;
      96:     }
      97:     flush();
      98:     if (intty) {
      99:         c = read(0, inline, sizeof inline - 4);
     100:         if (c < 0)
     101:             return (lastc = EOF);
     102:         if (c == 0 || inline[c-1] != '\n')
     103:             inline[c++] = CTRL(d);
     104:         if (inline[c-1] == '\n')
     105:             noteinp();
     106:         inline[c] = 0;
     107:         for (c--; c >= 0; c--)
     108:             if (inline[c] == 0)
     109:                 inline[c] = QUOTE;
     110:         input = inline;
     111:         goto top;
     112:     }
     113:     c = read(0, inline, sizeof inline - 1);
     114:     if(c <= 0)
     115:         return(lastc = EOF);
     116:     inline[c] = '\0';
     117:     input = inline;
     118:     goto top;
     119: }
     120:
     121: /*
     122:  * Input routine for insert/append/change in command mode.
     123:  * Most work here is in handling autoindent.
     124:  */
     125: static  short   lastin;
     126:
     127: gettty()
     128: {
     129:     register int c = 0;
     130:     register char *cp = genbuf;
     131:     char hadup = 0;
     132:     int numbline();
     133:     extern int (*Pline)();
     134:     int offset = Pline == numbline ? 8 : 0;
     135:     int ch;
     136:
     137:     if (intty && !inglobal) {
     138:         if (offset) {
     139:             holdcm = 1;
     140:             printf("  %4d  ", lineDOT() + 1);
     141:             flush();
     142:             holdcm = 0;
     143:         }
     144:         if (value(AUTOINDENT) ^ aiflag) {
     145:             holdcm = 1;
     146: #ifdef LISPCODE
     147:             if (value(LISP))
     148:                 lastin = lindent(dot + 1);
     149: #endif
     150:             tab(lastin + offset);
     151:             while ((c = getcd()) == CTRL(d)) {
     152:                 if (lastin == 0 && isatty(0) == -1) {
     153:                     holdcm = 0;
     154:                     return (EOF);
     155:                 }
     156:                 lastin = backtab(lastin);
     157:                 tab(lastin + offset);
     158:             }
     159:             switch (c) {
     160:
     161:             case '^':
     162:             case '0':
     163:                 ch = getcd();
     164:                 if (ch == CTRL(d)) {
     165:                     if (c == '0')
     166:                         lastin = 0;
     167:                     if (!OS) {
     168:                         putchar('\b' | QUOTE);
     169:                         putchar(' ' | QUOTE);
     170:                         putchar('\b' | QUOTE);
     171:                     }
     172:                     tab(offset);
     173:                     hadup = 1;
     174:                     c = getchar();
     175:                 } else
     176:                     ungetchar(ch);
     177:                 break;
     178:
     179:             case '.':
     180:                 if (peekchar() == '\n') {
     181:                     ignchar();
     182:                     noteinp();
     183:                     holdcm = 0;
     184:                     return (EOF);
     185:                 }
     186:                 break;
     187:
     188:             case '\n':
     189:                 hadup = 1;
     190:                 break;
     191:             }
     192:         }
     193:         flush();
     194:         holdcm = 0;
     195:     }
     196:     if (c == 0)
     197:         c = getchar();
     198:     while (c != EOF && c != '\n') {
     199:         if (cp > &genbuf[LBSIZE - 2])
     200:             error("Input line too long");
     201:         *cp++ = c;
     202:         c = getchar();
     203:     }
     204:     if (c == EOF) {
     205:         if (inglobal)
     206:             ungetchar(EOF);
     207:         return (EOF);
     208:     }
     209:     *cp = 0;
     210:     cp = linebuf;
     211:     if ((value(AUTOINDENT) ^ aiflag) && hadup == 0 && intty && !inglobal) {
     212:         lastin = c = smunch(lastin, genbuf);
     213:         for (c = lastin; c >= value(TABSTOP); c -= value(TABSTOP))
     214:             *cp++ = '\t';
     215:         for (; c > 0; c--)
     216:             *cp++ = ' ';
     217:     }
     218:     CP(cp, genbuf);
     219:     if (linebuf[0] == '.' && linebuf[1] == 0)
     220:         return (EOF);
     221:     return (0);
     222: }
     223:
     224: /*
     225:  * Crunch the indent.
     226:  * Hard thing here is that in command mode some of the indent
     227:  * is only implicit, so we must seed the column counter.
     228:  * This should really be done differently so as to use the whitecnt routine
     229:  * and also to hack indenting for LISP.
     230:  */
     231: smunch(col, ocp)
     232:     register int col;
     233:     char *ocp;
     234: {
     235:     register char *cp;
     236:
     237:     cp = ocp;
     238:     for (;;)
     239:         switch (*cp++) {
     240:
     241:         case ' ':
     242:             col++;
     243:             continue;
     244:
     245:         case '\t':
     246:             col += value(TABSTOP) - (col % value(TABSTOP));
     247:             continue;
     248:
     249:         default:
     250:             cp--;
     251:             CP(ocp, cp);
     252:             return (col);
     253:         }
     254: }
     255:
     256: char    *cntrlhm =  "^H discarded\n";
     257:
     258: checkjunk(c)
     259:     char c;
     260: {
     261:
     262:     if (junkbs == 0 && c == '\b') {
     263:         write(2, cntrlhm, 13);
     264:         junkbs = 1;
     265:     }
     266: }
     267:
     268: line *
     269: setin(addr)
     270:     line *addr;
     271: {
     272:
     273:     if (addr == zero)
     274:         lastin = 0;
     275:     else
     276:         getline(*addr), lastin = smunch(0, linebuf);
     277: }

#### Defined functions

checkjunk defined in line 258; used 1 times

- in line 50

getach defined in line 71; used 1 times

- in line 42

getcd defined in line 37; used 6 times

- in line 32, 67, 151, 163
- in /usr/src/ucb/ex/ex_addr.c line 162
- in /usr/src/ucb/ex/ex_cmds.c line 95

getchar defined in line 27; never used
gettty defined in line 127; used 1 times

- in /usr/src/ucb/ex/ex.h line 365

ignchar defined in line 22; used 19 times

- in line 181
- in /usr/src/ucb/ex/ex_cmds.c line 201, 366, 427, 480, 540, 641, 704, 843
- in /usr/src/ucb/ex/ex_cmds2.c line 191, 219
- in /usr/src/ucb/ex/ex_cmdsub.c line 496, 728, 1091
- in /usr/src/ucb/ex/ex_io.c line 520-523(2)
- in /usr/src/ucb/ex/ex_set.c line 31, 79
- in /usr/src/ucb/ex/ex_subr.c line 603

peekcd defined in line 64; used 2 times

- in /usr/src/ucb/ex/ex_addr.c line 90, 147

peekchar defined in line 56; used 56 times

- in line 180
- in /usr/src/ucb/ex/ex_addr.c line 68
- in /usr/src/ucb/ex/ex_cmds.c line 150, 184, 202, 265, 365-367(2), 385, 411, 428, 479-481(2), 538, 553, 625, 640-642(2), 669, 699-702(2), 842
- in /usr/src/ucb/ex/ex_cmds2.c line 32, 218, 400(2), 446-448(2), 458
- in /usr/src/ucb/ex/ex_cmdsub.c line 492(2), 498, 727, 1090
- in /usr/src/ucb/ex/ex_io.c line 129-134(2), 156, 519-522(2)
- in /usr/src/ucb/ex/ex_re.c line 603, 681, 725(3)
- in /usr/src/ucb/ex/ex_set.c line 30, 40, 78, 100, 122, 161(2)
- in /usr/src/ucb/ex/ex_subr.c line 601
- in /usr/src/ucb/ex/ex_unix.c line 41
- in /usr/src/ucb/ex/ex_v.c line 83, 221-224(2)

setin defined in line 268; used 4 times

- in /usr/src/ucb/ex/ex.h line 343
- in /usr/src/ucb/ex/ex_cmds.c line 176, 239, 318

smunch defined in line 231; used 2 times

- in line 212, 276

#### Defined variables

cntrlhm defined in line 256; used 1 times

- in line 263

junkbs defined in line 19; used 2 times

- in line 262-264(2)

lastc defined in line 20; used 10 times

- in line 86, 92, 101, 115
- in /usr/src/ucb/ex/ex.h line 245, 252
- in /usr/src/ucb/ex/ex_get.c line 86, 92, 101, 115

lastin defined in line 125; used 12 times

- in line 148-157(6), 166, 212-213(3), 274-276(2)

sccsid defined in line 8; never used

Last modified: 1991-09-08 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1722 |