2.11BSD#431 - /usr/src/new/OLD/apl/src/cata.c

   1: static char Sccsid[] = "cata.c @(#)cata.c	1.1	10/1/82 Berkeley ";
   2: #
   3: 
   4: /*
   5: 
   6: cata.c	-- cat files in apl format
   7: 
   8: Usage:  cata file1 file2 file3...
   9: 	catb file1 file2 file3.....
  10: 	cata [-bl] file1 file2 file3...
  11: can also be used as a filter, i.e.  cat file ^ cata ^ opr
  12: 
  13: cat? copies each line from the input file to the output
  14: file, preceding each line with the line number in brackets.
  15: the first line of each file is assumed to be the
  16: function name and is printed without a line number.
  17: 
  18: cata performs overprints by backspacing and printing
  19: the overprint character directly on top of the base
  20: character.
  21: catb captures each overprinted character and prints
  22: it on the line after its occurance, underneath
  23: the character that formed the base of the overprint.
  24: 
  25: cata.c is the program used to generate the binary:
  26: the binary is linked to two file names: cata and catb
  27: the program checks to detemine which one was called
  28: and executes accordingly.
  29: cata and catb are generated by compiling cata.c :
  30: 	cc cata.c -m -O ; mv a.out cata
  31: 	ln cata catb
  32: note:   cata and catb must be linked together
  33: 
  34: flags:
  35: Two flags are currently available to cata.
  36: -l disables the printing of line numbers.
  37: -b puts cata into the catb mode of printing lines.
  38: examples:
  39: 	cata -l w1	print w1 in cata mode without line numbers
  40: 	cata -b w1	print w1 in catb mode
  41: 	cata -bl w1	print w1 in catb mode without line numbers
  42: 	cata w1		print w1 in cata mode
  43: 
  44: as of 10/23/78 cata and catb are linked together.
  45: using catb is equivilent to typing:  cata  -b
  46: default argument is to print line numbers and use cata mode.
  47: hopefully at the beginning of spring 79 semester,
  48: catb will be removed and apl users will use
  49: cata -b  to perform the same function.
  50: 
  51: 
  52: author:  a.p. reeves
  53: 10/21/78
  54: modified for buffered i/o and fixed 'blank line' bug
  55: added dual link ability
  56: added -l and -b flags.
  57: r.l. reeves
  58: 
  59: 01/15/79
  60: modified for standard i/o package
  61: John Bruner
  62: */
  63: 
  64: #include <stdio.h>
  65: 
  66: FILE *infile;       /* input file pointer */
  67: 
  68: char *buf, line[128];   /* overprint buffer for catb mode */
  69:             /* buf will be called newprint buffer */
  70: 
  71: int catb =  0;      /* catb mode if non-zero */
  72: int lflg  = 1;      /* list line numbers if non-zero */
  73: 
  74: main(argc,argv)
  75: int argc;char **argv;
  76: {
  77: 
  78:     int iarg;   /* index of string being processed from argument list */
  79:     register int frstim;    /* first time flag--on if first time */
  80:                 /* through main printing loop */
  81:     register char *ap;  /* point to char in flag argument */
  82:     extern char _sobuf[];
  83: 
  84:     /* force buffering */
  85:     setbuf(stdout, _sobuf);
  86: 
  87:     /* set up newprint buffer to have leading tab */
  88:     *line = '\t';
  89:     buf = &line[1];
  90: 
  91:     /*
  92: 	* detect which file is being run of the two
  93: 	* possible file links.
  94: 	* set catb if file 'catb' is running
  95: 	*/
  96: 
  97:     if(argv[0][3] == 'b')
  98:         catb++;
  99: 
 100:     iarg = 1;
 101: 
 102:     /*
 103: 	* check for flag argument
 104: 	*/
 105: 
 106:     if(argc > 1 && *argv[1] == '-') {
 107:         ap = argv[1];
 108:         while(*++ap) switch(*ap) {
 109:             case 'b':   /* set catb mode */
 110:                     catb++;
 111:                     break;
 112:             case 'l':   /* no line numbers */
 113:                     lflg = 0;
 114:                     break;
 115:         }
 116:         iarg++;
 117:     }
 118: 
 119: 
 120:     frstim = 1; /* first time through main loop, print std input */
 121:             /* in case no files given */
 122: 
 123:     while (argc > iarg || frstim) {
 124: 
 125:         if(argc > iarg){
 126:             /* process argument list of files */
 127:             close(0);
 128:             if(open(argv[iarg], 0) != 0){
 129:                 printf("can't open input file: %s\n", argv[iarg]);
 130:                 exit(1);
 131:             }
 132:         }
 133: 
 134:         catfil();   /* print file */
 135: 
 136:         frstim = 0;
 137: 
 138:         /* advance to next file in argument list */
 139:         putchar('\n');
 140:         iarg++;
 141: 
 142:     }   /* end while */
 143: 
 144:     /* dump buffers and exit */
 145: 
 146:     exit(0);
 147: }   /* end main */
 148: 
 149: 
 150: /*
 151: * catfil -- routine to print current file to standard output
 152: */
 153: 
 154: catfil() {
 155: 
 156:     register int new, orig; /* index into newprint buffer */
 157:                 /* and original input buffer */
 158:     int lincnt;     /* line counter */
 159:     register char c;    /* character read in from input */
 160: 
 161: /* copy first line in file verbatim -- this is function name */
 162:     printf("\n\n\t");
 163:     while((c=getchar()) != EOF && putchar(c) != '\n');
 164:     if(c == '\0') return;
 165: 
 166: /*
 167: * copy remainder of file placing line numbers in front
 168: * of each line.
 169: */
 170: 
 171:     lincnt = 1;
 172:     while((c=getchar()) != EOF){
 173: 
 174:         new = orig = 0;
 175: 
 176:         /* print line number */
 177:         if(lflg) printf(" [%d]\t%c",lincnt,c);
 178:         else printf("\t%c",c);
 179: 
 180:         /* if not end of line, copy until then */
 181:         if( c != '\n' ) {
 182: 
 183:             while((c = getchar()) && c != '\n'){
 184:                if(catb) {
 185:                 if(c != '\b'){
 186:                     putchar (c);
 187:                     orig++;
 188:                 } else {
 189:                     while(new < orig)  buf[new++] = ' ';
 190:                     c = buf[new++] = getchar();
 191:                 }
 192:                } else {
 193:                 putchar(c);
 194:                }
 195:             }
 196: 
 197:             putchar('\n');
 198: 
 199:             /* perform newprint if needed */
 200:             if(catb && new) {
 201:                 buf[new++] = '\n';
 202:                 buf[new] = '\0';
 203:                 printf(line);
 204:             }
 205: 
 206:         }
 207: 
 208:         if(c == '\0') return;
 209: 
 210:         /* increment line counter */
 211:         lincnt++;
 212:     }
 213: 
 214:     return;
 215: 
 216: }

Defined functions

Defined variables