home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 13 / CDA13.ISO / cdactual / demobin / share / program / C / APR.ZIP / APR.C
Encoding:
C/C++ Source or Header  |  1979-12-31  |  12.8 KB  |  576 lines
  1. /*
  2.  
  3. NAME
  4.     apr -- source print utility
  5.  
  6. SYNOPSIS
  7.     apr [ -FHbfhlnpst ] [ files ... ]
  8.  
  9. DESCRIPTION
  10.     Apr prints the named files on the stdout. If the file specification
  11.    is '-' or no files were specified, the stdin is assumed. The   
  12.    listing is     separated into pages with the fixed size (user can  
  13.    configure any desired page size). By default, plain pages will be 
  14.    produced, but this option allows to set up either header with file 
  15.    status data and footer with page numbers, or custom header/footer.
  16.    Apr also recognizes text patterns as page-advance     commands. This
  17.    means that a new page will be forced whenever the program     finds
  18.    that pattern at the first column of the input line.
  19.  
  20.  
  21. OPTIONS
  22.     -F <string>    Use <string> as the message to be printed in the footer
  23.         instead of the copyright. Note that this option is ignored if
  24.         -s option is not used.
  25.  
  26.     -H <string>    Use <string> as the message to be printed in the header
  27.         instead of the file name and it's size. Note that this option
  28.         is ignored if -s option is not used.
  29.  
  30.     -b <string> Program will force a new page each time when it finds 
  31.         <string> at the beginning of the input line. Default value of
  32.         <string> is /**.
  33.  
  34.     -f <number> Set the bottom margin to <number> lines (default 2).
  35.  
  36.     -h <number> Set the top margin to <number> lines (default 0).
  37.  
  38.     -l <number> Set the line width to <number> characters (default 78).
  39.  
  40.     -n    Use the form-feed character for new pages (default is newlines).
  41.  
  42.     -p <number>    Set page length to <number> lines (default 72).
  43.  
  44.     -r Provide 6-digit line numbering.
  45.  
  46.     -s Enable headers and footers.
  47.  
  48.     -t <number>    Set tab-size to <number> characters (default 4).
  49.  
  50. FILES
  51.  
  52. VARIABLES
  53.  
  54. CAVEATS
  55.  
  56. SEE ALSO
  57.  
  58. REFERENCES
  59.  
  60. REVISIONS
  61.     10/15/88        Andreo Curko, NightWingers:    tested
  62.     11/14/88        Andreo Curko, NightWingers:    documented
  63.    12/13/88    Tom Sagrak,   NightWingers:   revised for uploading
  64.  
  65. COPYRIGHT
  66.     Copyright (c) 1988 by NightWingers, Zagreb
  67.  
  68.                      Tom Sagrak
  69.                      Draskoviceva 29
  70.                      YU-41000 ZAGREB
  71.                      Yugoslavia
  72.             
  73.     Permission to use, copy, modify, and distribute this
  74.     software and its documentation for any purpose and without
  75.     fee is hereby granted, provided that the above copyright
  76.     notice appears in all copies and that both that copyright
  77.     notice and this permission notice appear in supporting
  78.     documentation, and that the name of NightWingers not be used
  79.     in advertising or publicity pertaining to distribution of 
  80.     the software without specific, written prior permission.
  81.     NightWingers makes no representations about the suitability of
  82.     this software for any purpose.  It is provided "as is"
  83.     without express or implied warranty.
  84.  
  85.    If you find apr of value, and like to use it, a contribution of
  86.    $ 5 or more would be appreciated.
  87.  
  88. */
  89.  
  90. #include <errno.h>
  91. #include <ctype.h>
  92. #include <string.h>
  93. #include <stdio.h>
  94. #include <time.h>
  95. #include <sys/types.h>
  96. #include <sys/stat.h>
  97.  
  98. #ifdef UNIX
  99. #include <sys/timeb.h> 
  100. #endif
  101.  
  102. #ifdef MSDOS
  103. #include <stdlib.h>
  104. #include <process.h>
  105. #include <io.h>
  106. #endif
  107.  
  108. #define TRUE        1
  109. #define FALSE        0
  110. #define OUTPUT        stdout
  111. #define NO_ERRS    0
  112. #define NP_ERR        1
  113. #define USAGE        1
  114.  
  115. #ifdef UNIX
  116. extern int getopt();
  117. extern int optind;
  118. extern char *optarg;
  119. #endif
  120.  
  121.  
  122.  
  123. /**/
  124. #ifdef MSDOS
  125. /*
  126. * name    getopt - parse the command line options, System V style.
  127. *
  128. * synopsis    int getopt(argc, argv, optionS);
  129. *            int argc;       no. of arguments in the command line
  130. *            char *argv[];   argument vector
  131. *            char *optionS;  definition list of options
  132. *            extern int optind;    index of the next argument
  133. *            extern char *optarg;  current option's argument
  134. *
  135. * description    Standard option syntax is:
  136. *                option ::= SW [optLetter] [argLetter space* argument]
  137. *                where
  138. *                - SW is '-'
  139. *                - there is no space before any optLetter or argLetter.
  140. *                - opt/arg letters are alphabetic, not punctuation characters.
  141. *                - optLetter, if present, must be matched in optionS.
  142. *                - argLetters, if present, are found in optionS followed by ':'.
  143. *                - argument is any white-space delimited string.  Note that it
  144. *                  can include the SW character.
  145. *                - upper and lower case letters are distinct.
  146. * returns    (int) ch    - current option if OK
  147. *                        - '?' if error in argument vector
  148. *                        - EOF when no more options
  149. *
  150. **/
  151.  
  152. int    optind    = 1;    /* index of which argument is next    */
  153. char   *optarg;        /* pointer to argument of current option */
  154.  
  155. static    char   *letP;    /* remember next option char's location */
  156. static    char    SW = '-';        /* switch character */
  157.  
  158. int    
  159. getopt(argc,argv,optionS)
  160.     int argc;
  161.     char *argv[], *optionS;
  162. {
  163.     unsigned char ch;
  164.     char *optP;
  165.  
  166.     if (argc > optind) {
  167.         if ((letP = argv[optind]) == NULL || *(letP++) != SW)
  168.             goto gopEOF;
  169.         if (*letP == SW) {
  170.             optind++;
  171.             goto gopEOF;
  172.         }
  173.         if ((ch = *(letP++)) == '\0') {
  174.             optind++;
  175.             goto gopEOF;
  176.         }
  177.         if (ch == ':' ||  (optP = strchr(optionS, ch)) == NULL) {
  178.             optind++;
  179.             goto gopError;
  180.         }
  181.         if (*(++optP) == ':') {
  182.             optind++;
  183.             if (*letP == '\0') {
  184.                 if (argc <= optind)
  185.                     goto  gopError;
  186.                 letP = argv[optind++];
  187.             }
  188.             optarg = letP;
  189.             letP = NULL;
  190.         } 
  191.         else {
  192.             optind++;
  193.             letP = NULL;
  194.             optarg = NULL;
  195.         }
  196.         return ch;
  197.     }
  198. gopEOF:
  199.     optarg = letP = NULL;
  200.     return EOF;
  201.  
  202. gopError:
  203.     optarg = NULL;
  204.     return ('?');
  205. }
  206. #endif
  207.  
  208. /**/
  209. #define LINESIZE 512
  210. #define OPTDEFS "p:l:t:b:h:f:F:H:nsr"        /* program options     */
  211.  
  212. static struct stat statbuf;        /* buffer for a stat info                */
  213. static    FILE *input;               /* current input stream                    */
  214. static char globline[LINESIZE],    /* global buffer for input line            */
  215.             cbrk[] = "/\**",    /* default page-break string            */
  216.             *brkstring,            /* default page-advance string            */
  217.             *foottext,            /* pointer to footer message            */
  218.             *nofile = "(stdin)",/* if no filename specified                */
  219.             *filename,            /* name of file currently printed        */
  220.             *filetime,            /* it's time of the last modification    */
  221.             brkbuf[24],            /* buffer for a page-break string        */
  222.             footbuf[60],        /* buffer for a footer message            */
  223.             headbuf[60];        /* buffer for a header message            */
  224. static int tabsize = 4,            /* de~r}i}i~fault tab width                    */
  225.             brklen = 3,            /* length of page-advance string        */
  226.             footlen = 30,        /* length of the footer message            */
  227.             lines_per_page = 72,/* physical page length in lines        */
  228.             header_margin = 0,    /* default values for header and        */
  229.             footer_margin = 2,    /*    footer margin                        */
  230.             no_ff = TRUE,        /* use <LF> instead of <FF>                */
  231.             line_number = 0,    /* line counter                            */
  232.             do_lnum = FALSE,    /* if set lines will be numbered        */
  233.             A_status = FALSE,    /* if set status lines will be ON        */
  234.             footmessage = FALSE,/* if set user defines footer text        */
  235.             headmessage = FALSE,/* if set user defines header text        */
  236.             linesize = 78,        /* default paper width in chars            */
  237.             paperwidth,            /* info for header() and footer()        */
  238.             ln_cnt,                /* line number in a single input line    */
  239.             page_no;            /* current page number in a stream        */
  240. static long flsize;                /* it's size in bytes                    */
  241.  
  242. static char *copywr = "(C) NightWingers 1988";
  243.  
  244. /**/
  245. #ifdef MSDOS
  246.  
  247. static void 
  248. usage()
  249. {
  250.     fprintf(stderr,"Apr Source Print Utility Version 2.0\n");
  251.     fprintf(stderr,"Copyright (C) NightWingers 1988. All rights reserved.\n");
  252.     fprintf(stderr,"usage: apr [options] [file ...]\n");
  253.     fprintf(stderr,"options: -FHbfhlnpst\n");
  254.     fprintf(stderr," F <string> - redefine footer message (only with -s option)\n");
  255.     fprintf(stderr," H <string> - redefine header message (only with -s option)\n");
  256.     fprintf(stderr," b <string> - redefine page-break string (/\**)\n");
  257.     fprintf(stderr," f <number> - bottom margin in lines (2)\n");
  258.     fprintf(stderr," h <number> - top margin in lines (0)\n");
  259.     fprintf(stderr," l <number> - paper width in characters (78)\n");
  260.     fprintf(stderr," n - use <FF> instead of <nl> for new page (<nl>)\n");
  261.     fprintf(stderr," p <number> - paper size in lines (72)\n");
  262.     fprintf(stderr," r - include line numbers (NO)\n");
  263.     fprintf(stderr," s - output with status (NO)\n");
  264.     fprintf(stderr," t <number> - tab distance in characters (4)\n");
  265.     fprintf(stderr,"example: apr -s -F \"Acct. procs\" -t 8 -h 4 *.awk | lpr");
  266.     exit(USAGE);
  267. }
  268.  
  269. #else
  270.  
  271. static void
  272. usage()
  273. {
  274.     fprintf(stderr,"usage: apr [-FHbfhlnpst] [file ...]\n");
  275.     exit(USAGE);
  276. }
  277.  
  278. #endif
  279.  
  280. /**
  281. * 
  282. * name            header
  283. *
  284. * synopsis        void header();
  285. *        
  286. * description    
  287. *
  288. * return        -*-
  289. *
  290. **/
  291.  
  292. static void
  293. header()
  294. {
  295.     int i = header_margin;
  296.     int g;
  297.     
  298.     while (i--)
  299.         fputc('\n',OUTPUT);
  300.     if (A_status) {
  301.         if (headmessage) {
  302.             g = paperwidth - (strlen(headbuf) + 24);
  303.             fprintf(OUTPUT,"%-s",headbuf);
  304.         }
  305.         else {
  306.             g = (paperwidth - (strlen(filename) + 6 + 24)) >> 1;
  307.             fprintf(OUTPUT,"%-s",filename);
  308.             for (i=0; i<g; i++)
  309.                 fputc(' ',OUTPUT);
  310.             if (flsize)
  311.                 fprintf(OUTPUT,"%-6ld",flsize);
  312.             else
  313.                 fprintf(OUTPUT,"%6s","      ");
  314.         }
  315.         for (i=0; i<g; i++)
  316.             fputc(' ',OUTPUT);
  317.         fprintf(OUTPUT,"%-s",filetime);
  318.         for (i = 0;i < paperwidth;i++)
  319.             fputc('_',OUTPUT);
  320.         fprintf(OUTPUT,"\n\n");
  321.     }
  322.     ln_cnt = lines_per_page - header_margin - footer_margin;
  323. }
  324.  
  325. /**
  326. * 
  327. * name            footer
  328. *
  329. * synopsis        void footer();
  330. *        
  331. * description    
  332. *
  333. * return        -*-
  334. *
  335. **/
  336.  
  337. static void
  338. footer()
  339. {
  340.     int i = footer_margin;
  341.     int j;
  342.     char page_no_str[6];
  343.     
  344.     while (ln_cnt > 0) {
  345.         fputc('\n',OUTPUT);
  346.         ln_cnt--;
  347.     }
  348.     if (A_status) {
  349.         fputc('\n',OUTPUT);
  350.         for (j = 0;j < paperwidth;j++)
  351.             fputc('_',OUTPUT);
  352.         fprintf(OUTPUT,"\n%s", foottext);
  353.         for (j = 0; j < paperwidth-(footlen+5);j++)
  354.             fputc(' ',OUTPUT);
  355.         sprintf(page_no_str,"[%d]",page_no);
  356.         fprintf(OUTPUT,"%5s\n",page_no_str);
  357.     }
  358.     if (no_ff) {
  359.         while (i--)
  360.             fputc('\n',OUTPUT);
  361.     }
  362.     else
  363.         fputc('\f',OUTPUT);
  364.     page_no++;
  365. }
  366.  
  367. /**
  368. *
  369. * name            put_ln
  370. *
  371. * synopsis        void put_ln(line, lin_cnt);
  372. *                char *line;
  373. *                int lin_cnt;
  374. *
  375. * description    
  376. *
  377. * return        -*-
  378. *
  379. **/
  380.  
  381. static void
  382. put_ln(line, lin_cnt)
  383.     char *line;
  384.     int lin_cnt;
  385. {
  386.     char c;
  387.     register i,j;
  388.  
  389.     for(i=0;i<lin_cnt;i++) {
  390.         if(ln_cnt <= 0)
  391.             header();
  392.         if (do_lnum) {
  393.             if (i == 0) {
  394.                 line_number++;
  395.                 fprintf(OUTPUT,"%-6d:   ",line_number);
  396.             }
  397.             else
  398.                 fprintf(OUTPUT,"      :   ");
  399.         }
  400.         for(j=0;j<linesize && *line;j++) {
  401.             c = *line++;
  402.             fputc(c,OUTPUT);
  403.         }
  404.         if (c != '\n')
  405.             fputc('\n',OUTPUT);
  406.         ln_cnt--;
  407.         if(ln_cnt <= 0)
  408.             footer();
  409.     }
  410. }
  411.  
  412. /**
  413. *
  414. * name            do_ln 
  415. *
  416. * synopsis        void do_ln(line);
  417. *                char *line;
  418. *
  419. * description    
  420. *
  421. * return        -*-
  422. *
  423. **/
  424.  
  425. static void
  426. do_ln(line)
  427.     char *line;
  428. {
  429.     static char buf[512];
  430.     static char *p;
  431.     int cnt = 1;
  432.  
  433.     p = buf;
  434.     if ( ! strncmp(brkstring,line,brklen)) {
  435.         if (ln_cnt > 0)
  436.             footer();
  437.     }
  438.     while(*line) {
  439.         if(*line == '\t') {
  440.             do{
  441.                 *p++ = ' ';
  442.             } while(cnt++ % tabsize != 0);
  443.             ++line;
  444.         }
  445.         else {
  446.             ++cnt;
  447.             *p++ = *line++;
  448.         }
  449.     }
  450.     *p = '\0';
  451.     cnt = strlen(buf);
  452.     put_ln(buf, 1 + cnt/(linesize+1));
  453. }
  454.  
  455. static void
  456. do_file()
  457. {
  458.     char *l;
  459.     page_no = 1;
  460.     ln_cnt = line_number = 0;
  461.     while((l = fgets(globline, LINESIZE, input)) != NULL)
  462.         do_ln(l);
  463.     footer();
  464. }
  465.  
  466. /**/
  467. void
  468. main(argc, argv)
  469.   int argc;
  470.   char *argv[];
  471. {
  472.     int ch;
  473.     int pom;
  474.  
  475.     brkstring = cbrk;
  476.     while ((ch = getopt(argc,argv,OPTDEFS)) != EOF ) {
  477.         switch(ch) {
  478.             case 'l':
  479.                 pom = atoi(optarg);
  480.                 if (pom >= 40 && pom <= 255)
  481.                     linesize = pom;
  482.                 break;
  483.             case 't':
  484.                 pom = atoi(optarg);
  485.                 if (pom > 0 && pom <= 20)
  486.                     tabsize = pom;
  487.                 break;
  488.             case 'p':
  489.                 pom = atoi(optarg);
  490.                 if (pom >= 20) {
  491.                     if (A_status)
  492.                         lines_per_page = pom - 6;
  493.                     else
  494.                         lines_per_page = pom;
  495.                 }
  496.                 break;
  497.             case 'h':
  498.                 pom = atoi(optarg);
  499.                 if (pom >= 0 && pom <= 20)
  500.                     header_margin = pom;
  501.                 break;
  502.             case 'f':
  503.                 pom = atoi(optarg);
  504.                 if (pom >= 0 && pom <= 20)
  505.                     footer_margin = pom;
  506.                 break;
  507.             case 'n':
  508.                 no_ff = FALSE;
  509.                 break;
  510.             case 'r':
  511.                 do_lnum = TRUE;
  512.                 break;
  513.             case 's':
  514.                 if (! A_status)
  515.                     lines_per_page -= 6;
  516.                 A_status = TRUE;
  517.                 break;
  518.             case 'b':
  519.                 strcpy(brkbuf, optarg);
  520.                 brkstring = brkbuf;
  521.                 brklen = strlen(brkstring);
  522.                 break;
  523.             case 'F':
  524.                 strcpy(footbuf, optarg);
  525.                 footmessage = TRUE;
  526.                 break;
  527.             case 'H':
  528.                 strcpy(headbuf, optarg);
  529.                 headmessage = TRUE;
  530.                 break;
  531.             case '?':
  532.                 usage();
  533.                 break;
  534.         }
  535.     }
  536.     paperwidth = linesize;
  537.     if (do_lnum)
  538.         linesize -= 10;
  539.     if (footmessage) {
  540.         footlen = strlen(footbuf);
  541.         foottext = footbuf;
  542.     }
  543.     else {
  544.         foottext = copywr;
  545.     }
  546.     if (optind == argc) {                /* stdin */
  547.         filename = nofile;
  548.         time(&flsize);    
  549.         filetime = ctime(&flsize);
  550.         flsize = 0L;
  551.         input = stdin;
  552.         do_file();
  553.     }
  554.     else {
  555.         for(; optind<argc; ++optind) {
  556.             filename = argv[optind];
  557.             if (stat(argv[optind], &statbuf) == EOF) {
  558.                 perror(argv[optind]);
  559.                 exit(ENOENT);
  560.             }
  561.             if (!(statbuf.st_mode & 0x8000)) {
  562.                 fprintf(stderr,"%s: not an ordinary file\n",filename);
  563.                 exit(NP_ERR);
  564.              }
  565.             flsize = statbuf.st_size;
  566.             filetime = ctime(&(statbuf.st_mtime));
  567.             if((input = fopen(argv[optind], "r")) == NULL) {
  568.                 perror(argv[optind]);
  569.                 exit(EACCES);
  570.             }
  571.             do_file();
  572.         }
  573.     }
  574.     exit(NO_ERRS);
  575. }