# 2.11BSD#431 - /usr/src/usr.sbin/lpr/filters/vpf.c

##### Functions

    getline           X
    main              X
    putline           X
    send              X

##### Variables

    acctfile          X
    host              X
    indent            X
    length            X
    linebuf           X
    lineno            X
    literal           X
    name              X
    npages            X
    ov                X
    ovbuf             X
    pltmode           X
    prtmode           X
    varian            X
    width             X

##### Macros

    LINELN            X

       1: /*
       2:  * Copyright (c) 1983 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: #ifndef lint
       8: static char sccsid[] = "@(#)vpf.c	5.1 (Berkeley) 5/15/85";
       9: #endif not lint
      10:
      11: /*
      12:  * Varian/Versatec printer filter
      13:  */
      14:
      15: #include <signal.h>
      16: #include <stdio.h>
      17: #include <sys/vcmd.h>
      18:
      19: #define LINELN 440
      20:
      21: int pltmode[] = {VPLOT};
      22: int prtmode[] = {VPRINT};
      23: char    linebuf[LINELN+1];
      24: char    ovbuf[LINELN];
      25: int ov;
      26: int lineno;
      27: int varian = 1; /* default is the varian */
      28: int width = 132;    /* default line length */
      29: int indent = 0; /* default indent length */
      30: int length = 58;    /* 80 for 11" long paper */
      31: int npages = 1;
      32: int literal;
      33: char    *name;      /* user's login name */
      34: char    *host;      /* user's machine name */
      35: char    *acctfile;  /* accounting information file */
      36:
      37: main(argc, argv)
      38:     int argc;
      39:     char *argv[];
      40: {
      41:     register int i;
      42:
      43:     if (argv[0][strlen(argv[0])-1] == 'W') { /* Wide: the versatec. */
      44:         varian = 0;
      45:         width = 440;
      46:         length = 66;
      47:     }
      48:
      49:     while (--argc) {
      50:         if (*(*++argv) == '-') {
      51:             switch (argv[0][1]) {
      52:             case 'n':
      53:                 argc--;
      54:                 name = *++argv;
      55:                 break;
      56:
      57:             case 'h':
      58:                 argc--;
      59:                 host = *++argv;
      60:                 break;
      61:
      62:             case 'w':
      63:                 if ((i = atoi(&argv[0][2])) > 0 && i < LINELN)
      64:                     width = i;
      65:                 break;
      66:
      67:             case 'l':
      68:                 length = atoi(&argv[0][2]);
      69:                 break;
      70:
      71:             case 'i':
      72:                 if ((i = atoi(&argv[0][2])) >= 0 &&
      73:                     i < LINELN - 1)
      74:                     indent = i;
      75:                 break;
      76:
      77:             case 'c':   /* Print input without throwing away
      78: 					   control chars and without putting
      79: 					   in page breaks. */
      80:                 literal++;
      81:                 break;
      82:             }
      83:         } else
      84:             acctfile = *argv;
      85:     }
      86:     /*
      87: 	 * device should be open on file descriptor 1.
      88: 	 */
      89:     ioctl(1, VSETSTATE, prtmode);
      90:     send();
      91:     if (name && acctfile && access(acctfile, 02) >= 0 &&
      92:         freopen(acctfile, "a", stdout) != NULL) {
      93:         printf("%7.2f\t%s:%s\n", (float)npages, host, name);
      94:     }
      95:     exit(0);
      96: }
      97:
      98: send()
      99: {
     100:     lineno = 0;
     101:     while (getline()) {
     102:         if (varian && !literal && lineno >= length) {
     103:             putline(1);
     104:             lineno = 0;
     105:         } else
     106:             putline(0);
     107:     }
     108:     if (varian && lineno) {
     109:         putchar('\f');  /* be sure to end on a page boundary */
     110:         npages++;
     111:     }
     112:     /*
     113: 	 * Put out an extra null to ensure varian will get an even
     114: 	 * number of good characters.
     115: 	 */
     116:     putchar('\0');
     117: }
     118:
     119: getline()
     120: {
     121:     register col, maxcol, c;
     122:
     123:     ov = 0;
     124:     for (col = 0; col < width; col++) {
     125:         linebuf[col] = ' ';
     126:         ovbuf[col] = 0;
     127:     }
     128:     col = indent;
     129:     maxcol = 0;
     130:     for (;;) switch (c = getchar()) {
     131:
     132:     case EOF:
     133:         return(0);
     134:
     135:     case '\031':
     136:         /*
     137: 		 * lpd needs to use a different filter to print data so
     138: 		 * stop what we are doing and wait for lpd to restart us.
     139: 		 */
     140:         if ((c = getchar()) == '\1') {
     141:             putchar('\0');      /* make sure even # sent */
     142:             fflush(stdout);
     143:             kill(getpid(), SIGSTOP);
     144:             ioctl(1, VSETSTATE, prtmode);
     145:             continue;
     146:         }
     147:         ungetc(c, stdin);
     148:         c = '\031';
     149:         /* fall through if not stop sequence */
     150:     default:
     151:         if (c >= ' ' || literal) {
     152:             if (col < width) {
     153:                 if (linebuf[col] == '_') {
     154:                     ovbuf[col] = 0377;
     155:                     ov++;
     156:                 }
     157:                 linebuf[col++] = c;
     158:                 if (col > maxcol)
     159:                     maxcol = col;
     160:             } else
     161:                 col++;
     162:         }
     163:         continue;
     164:
     165:     case ' ':
     166:         col++;
     167:         continue;
     168:
     169:     case '\t':
     170:         col = (col|07) + 1;
     171:         continue;
     172:
     173:     case '\r':
     174:         col = 0;
     175:         continue;
     176:
     177:     case '_':
     178:         if (col < width) {
     179:             if (linebuf[col] != ' ') {
     180:                 ovbuf[col] = 0377;
     181:                 ov++;
     182:             } else
     183:                 linebuf[col] = c;
     184:             col++;
     185:             if (col > maxcol)
     186:                 maxcol = col;
     187:         } else
     188:             col++;
     189:         continue;
     190:
     191:     case '\f':
     192:         /* Fall through, treating a ff as a line break, too... */
     193:         lineno = length - 1;
     194:     case '\n':
     195:         if (maxcol > width)
     196:             maxcol = width;
     197:         linebuf[maxcol] = '\0';
     198:         if (++lineno % length == 0)
     199:             npages++;
     200:         return(1);
     201:
     202:     case '\b':
     203:         if (col > 0)
     204:             col--;
     205:         continue;
     206:     }
     207: }
     208:
     209: putline(ff)
     210: int ff;
     211: {
     212:     register char *lp;
     213:     register c, i;
     214:
     215:     lp = linebuf;
     216:     while (c = *lp++)
     217:         putchar(c);
     218:     if (ov) {
     219:         putchar('\n');
     220:         putchar('\0');
     221:         fflush(stdout);
     222:         ioctl(1, VSETSTATE, pltmode);
     223:         for (lp = ovbuf, i = ov; ov--; ) {
     224:             putchar(*lp & 0377);
     225:             putchar(*lp++ & 0377);
     226:         }
     227:         if (ov & 1)
     228:             putchar('\0');
     229:         fflush(stdout);
     230:         ioctl(1, VSETSTATE, prtmode);
     231:     }
     232:     if (ff)
     233:         putchar('\f');
     234:     else if (ov == 0)
     235:         putchar('\n');
     236:     if (ferror(stdout))
     237:         exit(1);
     238: }

#### Defined functions

getline defined in line 119; used 1 times

- in line 101

main defined in line 37; never used
putline defined in line 209; used 2 times

- in line 103-106(2)

send defined in line 98; used 1 times

- in line 90

#### Defined variables

acctfile defined in line 35; used 4 times

- in line 84, 91-92(3)

host defined in line 34; used 2 times

- in line 59, 93

indent defined in line 29; used 2 times

- in line 74, 128

length defined in line 30; used 5 times

- in line 46, 68, 102, 193-198(2)

linebuf defined in line 23; used 7 times

- in line 125, 153-157(2), 179-183(2), 197, 215

lineno defined in line 26; used 6 times

- in line 100-108(4), 193-198(2)

literal defined in line 32; used 3 times

- in line 80, 102, 151

name defined in line 33; used 3 times

- in line 54, 91-93(2)

npages defined in line 31; used 3 times

- in line 93, 110, 199

ov defined in line 25; used 8 times

- in line 123, 155, 181, 218-227(4), 234

ovbuf defined in line 24; used 4 times

- in line 126, 154, 180, 223

pltmode defined in line 21; used 1 times

- in line 222

prtmode defined in line 22; used 3 times

- in line 89, 144, 230

sccsid defined in line 8; never used
varian defined in line 27; used 3 times

- in line 44, 102, 108

width defined in line 28; used 7 times

- in line 45, 64, 124, 152, 178, 195-196(2)

#### Defined macros

LINELN defined in line 19; used 4 times

- in line 23-24(2), 63, 73

Last modified: 1987-02-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1089 |