home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff304.lzh / Multic / multic.c < prev    next >
C/C++ Source or Header  |  1990-01-10  |  5KB  |  250 lines
  1. /*
  2.  * Multic : multi-column text formatter
  3.  *
  4.  *     by Joel Swank 1/3/89
  5.  *
  6.  */
  7.  
  8. #include <stdio.h>
  9. #define FALSE 0
  10. #define TRUE 1
  11.  
  12. /* page format parameters  */
  13.  
  14. /* user selected parms     */
  15. int pagesize = 60;      /* Number of lines on a page        */
  16. int columns = 2;        /* number of print columns          */
  17. int linesize = 80;      /* size of output line              */
  18. int skip = 0;           /* lines between pages, 0= do '\f'  */
  19. int gap = 0;            /* space between columns            */
  20.  
  21. /* derived parms     */
  22. int colsize;            /* size of each column */
  23. int numptrs;            /* number of pointers needed */
  24.  
  25. /* stock of blanks for gap */
  26. char blanks[] = "                                                                                                    ";
  27. char *malloc(), *index();
  28.  
  29. char **pagebuf;        /* pointer to array of pointers for lines */
  30.  
  31. /****************************************************************/
  32. /*         Main program starts here                             */
  33. /****************************************************************/
  34.  
  35. main(argc,argv)
  36. int argc;
  37. char *argv[];
  38. {
  39.     int argindex;
  40.  
  41.     if (argc < 2)
  42.         {
  43.         usage();
  44.         exit(1);
  45.         }
  46.  
  47.  
  48.     /* parse the command line and execute the parameters */
  49.  
  50.     argindex = 0;
  51.  
  52.     while(--argc > 0)
  53.         {
  54.         argindex++;
  55.         do_parm(argv[argindex]);
  56.         }
  57.  
  58.  
  59. exit(0);
  60. }
  61.  
  62. /*
  63.  * do_file : process an input file
  64.  */
  65.  
  66. do_file(filename)
  67. char *filename;
  68. {
  69.     int curptr, ret, i, j, ptrsize;
  70.     char *inbuf, *nlptr;
  71.     FILE *in;
  72.     int Eoflag = FALSE;
  73.  
  74.     in = fopen(filename,"r");
  75.     if (in == NULL)
  76.         {
  77.         fprintf(stderr,"multic:cannot open %s\n",filename);
  78.         exit(7);
  79.         }
  80.  
  81.     /* calculate individual column size */
  82.     colsize = ((linesize-(columns-1)*gap)/columns);
  83.  
  84.     inbuf = malloc(colsize+1); /* allocate the input buffer */
  85.     if (!inbuf) memerr();
  86.  
  87.     /* allocate array of line pointers */
  88.     numptrs = (columns-1)*pagesize;
  89.     ptrsize = numptrs * sizeof(char *);
  90.     if (numptrs)
  91.         {
  92.         pagebuf = (char **) malloc(ptrsize);
  93.         setmem (pagebuf,ptrsize,'\0');
  94.         }
  95.  
  96.     while (!Eoflag)        /* do each page */
  97.         {
  98.         /* read in first columns-1 columns and store */
  99.         curptr = 0;
  100.         while (curptr < numptrs )
  101.             {
  102.             ret = fgets(inbuf,colsize+1,in);
  103.             if (!ret) 
  104.                 {
  105.                 Eoflag = TRUE;
  106.                 break;
  107.                 }
  108.             nlptr=index(inbuf,'\n');
  109.             if (nlptr) *nlptr = '\0';
  110.             pagebuf[curptr] = malloc(strlen(inbuf)+1);
  111.             if (!pagebuf[curptr]) memerr();
  112.             strcpy(pagebuf[curptr], inbuf);
  113.             curptr++;
  114.             }
  115.  
  116.         /* print out the page */
  117.         for (i=0; i< pagesize; i++)     /* do each line */
  118.             {
  119.             for (j=0; j< columns-1; j++)   /* do each column */
  120.                 {
  121.                 curptr = i+j*pagesize;
  122.                 if (j == 0 && pagebuf[i] == NULL && skip == 0) goto filedun;
  123.                 if (pagebuf[curptr])
  124.                     {
  125.                     printf("%-*.*s", colsize, colsize,pagebuf[curptr]);
  126.                     free (pagebuf[curptr]);
  127.                     pagebuf[curptr] = NULL;
  128.                     if (gap) printf("%.*s",gap,blanks);
  129.                     }
  130.                 else break;
  131.                 }
  132.             if (!Eoflag)
  133.                 {
  134.                 ret = fgets(inbuf,colsize+1,in);
  135.                 if (!ret) 
  136.                     {
  137.                     Eoflag = TRUE;
  138.                     if (columns == 1 && skip == 0) goto filedun;
  139.                     }
  140.                 else 
  141.                     {
  142.                     nlptr=index(inbuf,'\n');
  143.                     if (nlptr) *nlptr = '\0';
  144.                     printf("%.*s", colsize, inbuf);
  145.                     }
  146.                 }
  147.             putchar('\n');
  148.             }
  149.   filedun:
  150.         if (skip)
  151.             for (i=0; i< skip; i++) putchar('\n');
  152.         else putchar('\f');
  153.         }    /* end while(!Eoflag) */
  154.  
  155.     fclose(in);
  156.     free (inbuf);
  157.     if (pagebuf) free (pagebuf);
  158. }
  159.  
  160.  
  161. /*
  162.  * do_parm : process one parameter
  163.  */
  164.  
  165. do_parm(parm)
  166. unsigned char *parm;
  167. {
  168.     register int i,j;
  169.  
  170.     if (parm[0] == '-')
  171.         {
  172.         switch (parm[1])
  173.             {
  174.             case 'g':    /* set number of spaces between columns */
  175.               gap = atoi(&parm[2]);
  176.               if (gap <0 || gap > 100)
  177.                 {
  178.                   fprintf(stderr,"multic:Bad gap: %s\n",
  179.                    parm);
  180.                 exit(6);
  181.                 }
  182.               break;
  183.             case 's':    /* set number of lines between pages */
  184.               skip = atoi(&parm[2]);
  185.               if (skip <0 || skip > 100)
  186.                 {
  187.                   fprintf(stderr,"multic:Bad skip: %s\n",
  188.                    parm);
  189.                 exit(6);
  190.                 }
  191.               break;
  192.             case 'p':    /* set number of lines per page */
  193.               pagesize = atoi(&parm[2]);
  194.               if (pagesize <20 || pagesize > 500)
  195.                 {
  196.                   fprintf(stderr,"multic:Bad pagesize: %s\n",
  197.                    parm);
  198.                 exit(6);
  199.                 }
  200.               break;
  201.             case 'c':    /* set number of columns */
  202.               columns = atoi(&parm[2]);
  203.               if (columns <1 || columns > 9)
  204.                 {
  205.                   fprintf(stderr,"multic:Bad columns: %s\n",
  206.                    parm);
  207.                 exit(6);
  208.                 }
  209.               break;
  210.             case 'l':    /* set maximum line size */
  211.               linesize = atoi(&parm[2]);
  212.               if (linesize <20 || linesize > 999)
  213.                 {
  214.                   fprintf(stderr,"multic:Bad linesize: %s\n",
  215.                    parm);
  216.                 exit(6);
  217.                 }
  218.               break;
  219.             default:
  220.               fprintf(stderr,"multic:Bad flag: %s\n",parm);
  221.               usage();
  222.               exit(21);
  223.             }    /* end switch */
  224.     }else {
  225.         /* not a flag, must be a filename, so print it */
  226.         do_file(parm);
  227.         }
  228. }
  229.  
  230. /*
  231.  * exit for lack of memory.
  232.  */
  233.  
  234. memerr()
  235. {
  236.     fprintf(stderr,"Multic: Ran out of memory\n");
  237.     exit(10);
  238. }
  239.  
  240. usage()
  241. {
  242. fprintf(stderr,"Usage: multic: [[-cn] [-ln] [-pn] [-sn] [-gn] file ...] ...\n");
  243. fprintf(stderr,"Format file into multiple columns - args:\n");
  244. fprintf(stderr,"-cn   Format into n column output\n");
  245. fprintf(stderr,"-ln   Output line is n chatacters\n");
  246. fprintf(stderr,"-pn   Output page is n lines long\n");
  247. fprintf(stderr,"-sn   Skip n lines between pages\n");
  248. fprintf(stderr,"-gn   Skip n spaces between columns\n");
  249. }
  250.