home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / decode / uucat.zoo / uucat.c next >
Encoding:
C/C++ Source or Header  |  1991-04-01  |  6.9 KB  |  188 lines
  1. /*******************************************************************************
  2.  
  3.                                uucat(tm) v0.0
  4.  
  5.     COPYRIGHT:  This program is the sole property of Thomas D. Haynes.
  6.                             Copyright 1991.
  7.  
  8.     DISCLAIMER: While it was compilied with Turbo C++, it will work
  9.                 in Turbo C, and if you change the findfirst and
  10.                 findnext functions to the corresponding MSC functions,
  11.                 it ought to work with MSC.
  12.  
  13.                 Use of this product waives the author of any responsibilty
  14.                 of damage.  Face it, I've tested this software on my
  15.                 system, and if it wiped out my hard disk, I'd be sure
  16.                 to rewrite the code so that I could use it safely.
  17.  
  18.     AUTHOR:     Thomas D. Haynes
  19.  
  20.     FILE:   uucat       TYPE:   int               PROTOTYPE FILE:   N/A
  21.  
  22.     PURPOSE:    To concatonate uudecoded parts into one file.
  23.  
  24.     DATE:       03/31/91
  25.  
  26.     LANGUAGE:   Borland C++ v2.00
  27.  
  28.     FUNCTIONS CALLED:
  29.                 uuError
  30.                 uuClError
  31.                 uuGetParts
  32.  
  33.     LIBRARY FUNCTIONS CALLED:
  34.                 fclose              <stdio.h>
  35.                 findfirst           <dir.h>
  36.                 findnext            <dir.h>
  37.                 fgets               <stdio.h>
  38.                 fopen               <stdio.h>
  39.                 fprintf             <stdio.h>
  40.                 fputs               <stdio.h>
  41.                 memset              <string.h>
  42.                 strcat              <string.h>
  43.                 strcmp              <string.h>
  44.                 strcpy              <string.h>
  45.                 strncmp             <string.h>
  46.  
  47.     RETURN CODES:
  48.                 -1 if the input file can not be opened
  49.                 -2 if the output file can not be opened
  50.                 -3 if not enough command line arguements
  51.  
  52.     OTHER:
  53.                 uucat <output_file> <input_file>(s)
  54.  
  55.                 Where output_file is the destination file, and input_file
  56.                 is either a list of files to concatonate or a list of
  57.                 wildcarded filename of files to concatonate.
  58.  
  59.            Borland C++ is a Copyright of Borland International.
  60.  
  61. *******************************************************************************/
  62. #include <dir.h>
  63. #include <stdio.h>
  64. #include <string.h>
  65.  
  66. #define UUCAT_MAX_FILE       13
  67. #define UUCAT_MAX_LINE      257
  68. #define UUCAT_MAX_PARTS     512
  69.  
  70. static char *mine[] =
  71.     {
  72.     "COPYRIGHT:  This program is the sole property of Thomas D. Haynes.",
  73.     "                     ALL RIGHTS RESERVED                          ",
  74.     "                        Copyright 1991.                           "
  75.     };
  76.  
  77. void uuError(char *msg, char *file_name, int code)
  78. {
  79.     if (file_name[0] == '\0')
  80.         fprintf(stderr, "\nUUCAT ERROR:  %s.\n", msg);
  81.     else
  82.         fprintf(stderr, "\nUUCAT ERROR:  %s: %s \n", msg, file_name);
  83.  
  84.     exit(code);
  85. }
  86.  
  87. void uuClError(void)
  88. {
  89.     fprintf(stderr, "\nUUCAT ERROR:  Incorrect arguements.");
  90.     fprintf(stderr, "\n              uucat <output> <input>(s)\n");
  91.  
  92.     exit(-3);
  93. }
  94.  
  95. void uuGetParts(char **parts, char **argv, int argc, int *num_parts)
  96. {
  97. int j;                              /* loop variable                        */
  98. int i;                              /* loop variable                        */
  99. int done;                           /* flag if all files found              */
  100. struct ffblk ffblk_st;              /* structure containing found info      */
  101.  
  102.     *num_parts = 0;
  103.  
  104.     /*  If wildcard, get all the files to open                               */
  105.     for (i = 2; i < argc; i++)
  106.         {
  107.         if (strchr(argv[i], '*') || strchr(argv[i], '?'))
  108.             {
  109.             done = findfirst(argv[i], &ffblk_st, 0);
  110.             while (!done)
  111.                 {
  112.                 strcpy(parts[(*num_parts)++], ffblk_st.ff_name);
  113.                 done = findnext(&ffblk_st);
  114.                 }
  115.             }
  116.         else
  117.             strcpy(parts[(*num_parts)++], argv[i]);
  118.         }
  119. }
  120.  
  121. int main(int argc, char *argv[])
  122. {
  123. FILE *in_fp;                                        /* Input File pointer    */
  124. FILE *out_fp;                                       /* Output File pointer   */
  125. char buf[UUCAT_MAX_LINE];                           /* Buffer                */
  126. char in_file[UUCAT_MAX_FILE];                       /* Input File name       */
  127. char out_file[UUCAT_MAX_FILE];                      /* Output File name      */
  128. char begin_text[] = "BEGIN--cut here--cut here";    /* Beginning Text Marker */
  129. char end_text[] = "END--cut here--cut here";        /* Ending Text Marker    */
  130. char part_list[UUCAT_MAX_PARTS][UUCAT_MAX_FILE];    /* List of parts to ccat */
  131. char *part_ptrs[UUCAT_MAX_PARTS];                   /* Pointer to list parts */
  132. int j;                                              /* loop variable         */
  133. int j_end;                                          /* loop variable end     */
  134.  
  135.     /*  Check number of cmmand line arguements                               */
  136.     if (argc < 3)
  137.         uuClError();
  138.  
  139.     /*  Open output file                                                     */
  140.     if ((out_fp = fopen(argv[1], "wb")) == NULL)
  141.         uuError("Cannot open output file", argv[1], -2);
  142.  
  143.     /*  Get pointers to the Parts List                                       */
  144.     for (j = 0; j < UUCAT_MAX_PARTS; j++)
  145.         {
  146.         memset(part_list[j], '\0', UUCAT_MAX_FILE);
  147.         part_ptrs[j] = &part_list[j][0];
  148.         }
  149.  
  150.     /*  Get the Parts List                                                   */
  151.     uuGetParts(part_ptrs, argv, argc, &j_end);
  152.  
  153.     /*  Loop through, reading in each Part                                   */
  154.     for (j = 0; j < j_end; j++)
  155.         {
  156.         /*  Open up each Part for scanning                                   */
  157.         if ((in_fp = fopen(part_list[j], "rb")) == NULL)
  158.             uuError("Cannot open input file", part_list[j], -1);
  159.  
  160.         /*  First scan for the start of the UUENCODED text                   */
  161.         /*  Do not ouput anything                                            */
  162.         memset(buf, '\0', UUCAT_MAX_LINE);
  163.         while(fgets(buf, UUCAT_MAX_LINE, in_fp))
  164.             if (!strncmp(buf, begin_text, strlen(begin_text)))
  165.                 break;
  166.             else
  167.                 memset(buf, '\0', UUCAT_MAX_LINE);
  168.  
  169.         /*  Now scan for the end of the UUENCODED text                       */
  170.         /*  Output everything until end                                      */
  171.         memset(buf, '\0', UUCAT_MAX_LINE);
  172.         while(fgets(buf, UUCAT_MAX_LINE, in_fp))
  173.             if (!strncmp(buf, end_text, strlen(end_text)))
  174.                 break;
  175.             else
  176.                 {
  177.                 fputs(buf, out_fp);
  178.                 memset(buf, '\0', UUCAT_MAX_LINE);
  179.                 }
  180.  
  181.         fclose(in_fp);
  182.         }
  183.  
  184.     fclose(out_fp);
  185.  
  186.     return(0);
  187. }
  188.