home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / source / s2 / pr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1975-05-13  |  5.8 KB  |  450 lines
  1. #
  2. /*
  3.  *   print file with headings
  4.  *  2+head+2+page[56]+5
  5.  */
  6.  
  7. int    ncol    1;
  8. char    *header;
  9. int    col;
  10. int    icol;
  11. int    file;
  12. char    *bufp;
  13. #define    BUFS    5120
  14. char    buffer[BUFS];
  15. #define    FF    014
  16. int    line;
  17. char    *colp[72];
  18. int    nofile;
  19. char    isclosed[10];
  20. int    peekc;
  21. int    fpage;
  22. int    page;
  23. int    colw;
  24. int    nspace;
  25. int    width    72;
  26. int    length    66;
  27. int    plength 61;
  28. int    margin    10;
  29. int    ntflg;
  30. int    mflg;
  31. int    tabc;
  32. char    *tty;
  33. int    mode;
  34.  
  35. struct inode {
  36.     int dev;
  37.     int inum;
  38.     int flags;
  39.     char nlink;
  40.     char uid;
  41.     char gid;
  42.     char siz0;
  43.     int size;
  44.     int ptr[8];
  45.     int atime[2];
  46.     int mtime[2];
  47. };
  48.  
  49. main(argc, argv)
  50. char **argv;
  51. {
  52.     int nfdone;
  53.     int onintr();
  54.     extern fout;
  55.  
  56.     tty = "/dev/ttyx";
  57.     fout = dup(1);
  58.     close(1);
  59.     if ((signal(2, 1) & 01) == 0)
  60.         signal(2, onintr);
  61.     fixtty();
  62.     for (nfdone=0; argc>1; argc--) {
  63.         argv++;
  64.         if (**argv == '-') {
  65.             switch (*++*argv) {
  66.             case 'h':
  67.                 if (argc>=2) {
  68.                     header = *++argv;
  69.                     argc--;
  70.                 }
  71.                 continue;
  72.  
  73.             case 't':
  74.                 ntflg++;
  75.                 continue;
  76.  
  77.             case 'l':
  78.                 length = getn(++*argv);
  79.                 continue;
  80.  
  81.             case 'w':
  82.                 width = getn(++*argv);
  83.                 continue;
  84.  
  85.             case 's':
  86.                 if (*++*argv)
  87.                     tabc = **argv;
  88.                 else
  89.                     tabc = '\t';
  90.                 continue;
  91.  
  92.             case 'm':
  93.                 mflg++;
  94.                 continue;
  95.  
  96.             default:
  97.                 ncol = getn(*argv);
  98.                 continue;
  99.             }
  100.         } else if (**argv == '+') {
  101.             fpage = getn(++*argv);
  102.         } else {
  103.             print(*argv, argv);
  104.             nfdone++;
  105.             if (mflg)
  106.                 break;
  107.         }
  108.     }
  109.     if (nfdone==0)
  110.         print(0);
  111.     flush();
  112.     onintr();
  113. }
  114.  
  115. onintr()
  116. {
  117.  
  118.     chmod(tty, mode);
  119.     exit(0);
  120. }
  121.  
  122. fixtty()
  123. {
  124.     struct inode sbuf;
  125.     extern fout;
  126.  
  127.     tty[8] = ttyn(fout);
  128.     fstat(fout, &sbuf);
  129.     mode = sbuf.flags&0777;
  130.     chmod(tty, 0600);
  131. }
  132.  
  133. print(fp, argp)
  134. char *fp;
  135. char **argp;
  136. {
  137.     struct inode sbuf;
  138.     register int sncol, sheader;
  139.     register char *cbuf;
  140.     extern fout;
  141.  
  142.     if (ntflg)
  143.         margin = 0;
  144.     else
  145.         margin = 10;
  146.     if (length <= margin)
  147.         length = 66;
  148.     if (width <= 0)
  149.         width = 72;
  150.     if (ncol>72 || ncol>width) {
  151.         write(2, "Very funny.\n", 12);
  152.         exit();
  153.     }
  154.     if (mflg) {
  155.         mopen(argp);
  156.         ncol = nofile;
  157.     }
  158.     colw = width/ncol;
  159.     sncol = ncol;
  160.     sheader = header;
  161.     plength = length-5;
  162.     if (ntflg)
  163.         plength = length;
  164.     if (--ncol<0)
  165.         ncol = 0;
  166.     if (mflg)
  167.         fp = 0;
  168.     if (fp) {
  169.         file = open(fp, 0);
  170.         if (file<0)
  171.             return;
  172.         fstat(file, &sbuf);
  173.     } else {
  174.         file = 0;
  175.         time(sbuf.mtime);
  176.     }
  177.     if (header == 0)
  178.         header = fp;
  179.     cbuf = ctime(sbuf.mtime);
  180.     cbuf[16] = '\0';
  181.     cbuf[24] = '\0';
  182.     page = 1;
  183.     icol = 0;
  184.     colp[ncol] = bufp = buffer;
  185.     if (mflg==0)
  186.         nexbuf();
  187.     while (mflg&&nofile || (!mflg)&&tpgetc(ncol)>0) {
  188.         if (mflg==0) {
  189.             colp[ncol]--;
  190.             if (colp[ncol] < buffer)
  191.                 colp[ncol] = &buffer[BUFS];
  192.         }
  193.         line = 0;
  194.         if (ntflg==0) {
  195.             puts("\n\n");
  196.             puts(cbuf+4);
  197.             puts(" ");
  198.             puts(cbuf+20);
  199.             puts("  ");
  200.             puts(header);
  201.             puts(" Page ");
  202.             putd(page);
  203.             puts("\n\n\n");
  204.         }
  205.         putpage();
  206.         if (ntflg==0)
  207.             while(line<length)
  208.                 put('\n');
  209.         page++;
  210.     }
  211.     if (file)
  212.         close(file);
  213.     ncol = sncol;
  214.     header = sheader;
  215. }
  216.  
  217. mopen(ap)
  218. char **ap;
  219. {
  220.     register char **p, *p1;
  221.  
  222.     p = ap;
  223.     while ((p1 = *p++) && p1 != -1) {
  224.         isclosed[nofile] = fopen(p1, &buffer[2*259*nofile]);
  225.         if (++nofile>=10) {
  226.             write(2, "Too many args.\n", 15);
  227.             exit();
  228.         }
  229.     }
  230. }
  231.  
  232. putpage()
  233. {
  234.     register int lastcol, i, c;
  235.     int j;
  236.  
  237.     if (ncol==0) {
  238.         while (line<plength) {
  239.             while((c = tpgetc(0)) && c!='\n' && c!=FF)
  240.                 putcp(c);
  241.             putcp('\n');
  242.             line++;
  243.             if (c==FF)
  244.                 break;
  245.         }
  246.         return;
  247.     }
  248.     colp[0] = colp[ncol];
  249.     if (mflg==0) for (i=1; i<=ncol; i++) {
  250.         colp[i] = colp[i-1];
  251.         for (j = margin; j<length; j++)
  252.             while((c=tpgetc(i))!='\n')
  253.                 if (c==0)
  254.                     break;
  255.     }
  256.     while (line<plength) {
  257.         lastcol = colw;
  258.         for (i=0; i<ncol; i++) {
  259.             while ((c=pgetc(i)) && c!='\n')
  260.                 if (col<lastcol || tabc!=0)
  261.                     put(c);
  262.             if (c==0 && ntflg)
  263.                 return;
  264.             if (tabc)
  265.                 put(tabc);
  266.             else while (col<lastcol)
  267.                 put(' ');
  268.             lastcol =+ colw;
  269.         }
  270.         while ((c = pgetc(ncol)) && c!='\n')
  271.             put(c);
  272.         put('\n');
  273.     }
  274. }
  275.  
  276. nexbuf()
  277. {
  278.     register int n;
  279.     register char *rbufp;
  280.  
  281.     rbufp = bufp;
  282.     n = &buffer[BUFS] - rbufp;
  283.     if (n>512)
  284.         n = 512;
  285.     if ((n = read(file, rbufp, n)) <= 0)
  286.         *rbufp = 0376;
  287.     else {
  288.         rbufp =+ n;
  289.         if (rbufp >= &buffer[BUFS])
  290.             rbufp = buffer;
  291.         *rbufp = 0375;
  292.     }
  293.     bufp = rbufp;
  294. }
  295.  
  296. tpgetc(ai)
  297. {
  298.     register char **p;
  299.     register int c, i;
  300.  
  301.     i = ai;
  302.     if (mflg) {
  303.         if ((c = getc(&buffer[2*259*i])) < 0) {
  304.             if (isclosed[i]==0) {
  305.                 isclosed[i] = 1;
  306.                 if (--nofile <= 0)
  307.                     return(0);
  308.             }
  309.             return('\n');
  310.         }
  311.         if (c==FF && ncol>0)
  312.             c = '\n';
  313.         return(c);
  314.     }
  315. loop:
  316.     c = **(p = &colp[i]) & 0377;
  317.     if (c == 0375) {
  318.         nexbuf();
  319.         c = **p & 0377;
  320.     }
  321.     if (c == 0376)
  322.         return(0);
  323.     (*p)++;
  324.     if (*p >= &buffer[BUFS])
  325.         *p = buffer;
  326.     if (c==0)
  327.         goto loop;
  328.     return(c);
  329. }
  330.  
  331. pgetc(i)
  332. {
  333.     register int c;
  334.  
  335.     if (peekc) {
  336.         c = peekc;
  337.         peekc = 0;
  338.     } else
  339.         c = tpgetc(i);
  340.     if (tabc)
  341.         return(c);
  342.     switch (c) {
  343.  
  344.     case '\t':
  345.         icol++;
  346.         if ((icol&07) != 0)
  347.             peekc = '\t';
  348.         return(' ');
  349.  
  350.     case '\n':
  351.         icol = 0;
  352.         break;
  353.  
  354.     case 010:
  355.     case 033:
  356.         icol--;
  357.         break;
  358.     }
  359.     if (c >= ' ')
  360.         icol++;
  361.     return(c);
  362. }
  363.  
  364. puts(as)
  365. char *as;
  366. {
  367.     register int c;
  368.     register char *s;
  369.  
  370.     if ((s=as)==0)
  371.         return;
  372.     while (c = *s++)
  373.         put(c);
  374. }
  375.  
  376. putd(an)
  377. {
  378.     register int a, n;
  379.  
  380.     n = an;
  381.     if (a = n/10)
  382.         putd(a);
  383.     put(n%10 + '0');
  384. }
  385.  
  386. put(ac)
  387. {
  388.     register int ns, c;
  389.  
  390.     c = ac;
  391.     if (tabc) {
  392.         putcp(c);
  393.         if (c=='\n')
  394.             line++;
  395.         return;
  396.     }
  397.     switch (c) {
  398.  
  399.     case ' ':
  400.         nspace++;
  401.         col++;
  402.         return;
  403.  
  404.     case '\n':
  405.         col = 0;
  406.         nspace = 0;
  407.         line++;
  408.         break;
  409.  
  410.     case 010:
  411.     case 033:
  412.         if (--col<0)
  413.             col = 0;
  414.         if (--nspace<0)
  415.             nspace = 0;
  416.  
  417.     }
  418.     while(nspace) {
  419.         if (nspace>2 && col > (ns=((col-nspace)|07))) {
  420.             nspace = col-ns-1;
  421.             putcp('\t');
  422.         } else {
  423.             nspace--;
  424.             putcp(' ');
  425.         }
  426.     }
  427.     if (c >= ' ')
  428.         col++;
  429.     putcp(c);
  430. }
  431.  
  432. getn(ap)
  433. char *ap;
  434. {
  435.     register int n, c;
  436.     register char *p;
  437.  
  438.     p = ap;
  439.     n = 0;
  440.     while ((c = *p++) >= '0' && c <= '9')
  441.         n = n*10 + c - '0';
  442.     return(n);
  443. }
  444.  
  445. putcp(c)
  446. {
  447.     if (page >= fpage)
  448.         putchar(c);
  449. }
  450.