home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Mint / mntlib32.zoo / crlf / crlf.c next >
C/C++ Source or Header  |  1993-02-23  |  5KB  |  297 lines
  1. /* crlf.c 1.1 by entropy@terminator.rs.itd.umich.edu
  2.    PUBLIC DOMAIN -- NO RIGHTS RESERVED
  3.    NO WARRANTY -- USE AT YOUR OWN RISK!!!!!!!!!
  4.    strips/adds carriage returns from text files
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <string.h>
  11. #ifdef __atarist__
  12. #include <compiler.h>
  13. #ifdef __TURBOC__
  14. #include <sys\types.h>
  15. #include <sys\stat.h>
  16. #else /* not __TURBOC__ */
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #endif /* not __TURBOC__ */
  20. #else /* not __atarist__ */
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #ifdef sun
  24. #include <utime.h>
  25. #endif /* sun */
  26. #ifndef EXIT_FAILURE
  27. #define EXIT_FAILURE 2
  28. #endif /* EXIT_FAILURE */
  29. #ifndef EXIT_SUCCESS
  30. #define EXIT_SUCCESS 0
  31. #endif /* EXIT_SUCCESS */
  32. #ifdef __STDC__
  33. #ifndef __NO_PROTO__
  34. #define __PROTO(x) x
  35. #endif /* not __NO_PROTO__ */
  36. #define __EXTERN
  37. #else /* not __STDC__ */
  38. #define __EXTERN extern
  39. #define __PROTO(x) ()
  40. #endif /* not __STDC__ */
  41. #endif /* not __atarist__ */
  42.  
  43. __EXTERN int utime __PROTO((char *path, struct utimbuf *times));
  44.  
  45. extern char *optarg;
  46. extern int optind, opterr;
  47.  
  48. #define CR_STRIP 0
  49. #define CR_ADD 1
  50. #define CR_NONE 2
  51.  
  52. char *program = NULL;
  53.  
  54. void perror2 __PROTO((char *msg1, char *msg2));
  55. int crlf __PROTO((char *filename, int mode));
  56. int simple_outchar __PROTO((FILE *ofp, int c));
  57. int tounx_outchar __PROTO((FILE *ofp, int c));
  58. int totos_outchar __PROTO((FILE *ofp, int c));
  59. int smart_copy __PROTO((char *ifn, char *ofn, 
  60.                         int (*outcharfunc)(FILE *, int)));
  61.  
  62. void
  63. perror2(msg1, msg2)
  64.   char *msg1;
  65.   char *msg2;
  66. {
  67.   if (msg1 && *msg1)
  68.   {
  69.     fputs(msg1, stderr);
  70.     fputs(": ", stderr);
  71.   }
  72.   perror(msg2);
  73. }
  74.  
  75. int
  76. simple_outchar(ofp, c)
  77.   FILE *ofp;
  78.   int c;
  79. {
  80.   fputc(c, ofp);
  81.   return (c);
  82. }
  83.  
  84. int
  85. totos_outchar(ofp, c)
  86.   FILE *ofp;
  87.   int c;
  88. {
  89.   if (c == '\n')
  90.   {
  91.     fputc('\r', ofp);
  92.   }
  93.   fputc(c, ofp);
  94.   return (c);
  95. }
  96.  
  97. int
  98. tounx_outchar(ofp, c)
  99.   FILE *ofp;
  100.   int c;
  101. {
  102.   if (c != '\r')
  103.   {
  104.     fputc(c, ofp);
  105.   }
  106.   return (c);
  107. }
  108.  
  109. int
  110. smart_copy(ifn, ofn, outcharfunc)
  111.   char *ifn;
  112.   char *ofn;
  113.   int (*outcharfunc)(FILE *, int);
  114. {
  115.   FILE *ifp;
  116.   FILE *ofp;
  117.   int c;
  118.  
  119.   if ((ifp = fopen(ifn, "rb")) == NULL)
  120.   {
  121.     perror2(program, ifn);
  122.     return (-1);
  123.   }
  124.   if ((ofp = fopen(ofn, "wb")) == NULL)
  125.   {
  126.     fclose(ifp);
  127.     perror2(program, ofn);
  128.     return (-1);
  129.   }
  130.   c = fgetc(ifp);
  131.   while (!(feof(ifp)) && !(ferror(ifp)) && !(ferror(ofp)))
  132.   {
  133.     (*outcharfunc)(ofp, c);
  134.     c = fgetc(ifp);
  135.   }
  136.   if (ferror(ifp))
  137.   {
  138.     perror2(program, ifn);
  139.     fclose(ifp);
  140.     fclose(ofp);
  141.     return (-1);
  142.   }
  143.   if (ferror(ofp))
  144.   {
  145.     perror2(program, ofn);
  146.     fclose(ifp);
  147.     fclose(ofp);
  148.     return (-1);
  149.   }
  150.   if (fclose(ifp) == EOF)
  151.   {
  152.     perror2(program, ifn);
  153.     fclose(ofp);
  154.     return (-1);
  155.   }
  156.   if (fclose(ofp) == EOF)
  157.   {
  158.     perror2(program, ofn);
  159.     return (-1);
  160.   }
  161.   return (0);
  162. }
  163.  
  164. int
  165. crlf(filename, mode)
  166.   char *filename;
  167.   int mode; /* 0 == strip CR's, 1 == add CR's */
  168. {
  169.   char tempname[256];
  170.   int (*outcharfunc)(FILE *, int);
  171.  
  172.   strcpy(tempname, "/tmp/crlfXXXXXX");
  173.   if (mktemp(tempname) == NULL)
  174.   {
  175.     fputs(program, stderr);
  176.     fputs(": could not get a temporary filename\n", stderr);
  177.     return (-1);
  178.   }
  179.   switch (mode)
  180.   {
  181.     case CR_ADD:
  182.       outcharfunc = totos_outchar;
  183.       break;
  184.     case CR_STRIP:
  185.     default:
  186.       outcharfunc = tounx_outchar;
  187.       break;
  188.   }
  189.   if (smart_copy(filename, tempname, outcharfunc))
  190.   {
  191.     return (-1);
  192.   }
  193.   if (rename(tempname, filename))
  194.   {
  195.     if (smart_copy(tempname, filename, simple_outchar))
  196.     {
  197.       return (-1);
  198.     }
  199.     if (unlink(tempname))
  200.     {
  201.       perror2(program, tempname);
  202.       return (-1);
  203.     }
  204.   }
  205.   return (0);
  206. }
  207.  
  208. int
  209. main(int argc, char *argv[], char *envp[])
  210. {
  211.   char *fn = NULL;
  212.   int mode = CR_NONE;
  213.   int c;
  214.   int err = 0;
  215.   struct stat st;
  216.   struct utimbuf ut;
  217.   
  218.   program = argv[0];
  219.   while ((c = getopt(argc, argv, "as")) != EOF)
  220.   {
  221.     switch (c)
  222.     {
  223.       case 'a':
  224.         if (mode == CR_NONE)
  225.         {
  226.           mode = CR_ADD;
  227.            }
  228.         else
  229.         {
  230.           err++;
  231.         }
  232.         break;
  233.       case 's':
  234.         if (mode == CR_NONE)
  235.         {
  236.           mode = CR_STRIP;
  237.            }
  238.         else
  239.         {
  240.           err++;
  241.         }
  242.         break;
  243.       case '?':
  244.       default:
  245.         err++;
  246.         break;
  247.     }
  248.   }
  249.   if (mode == CR_NONE)
  250.   {
  251.     err++;
  252.   }
  253.   if (err || (optind >= argc))
  254.   {
  255.     fputs("usage:  ", stderr);
  256.     fputs(program, stderr);
  257.     fputs(" -s file [file2 [...]] (to strip carriage returns)\n", stderr);
  258.     fputs("        ", stderr);
  259.     fputs(program, stderr);
  260.     fputs(" -a file [file2 [...]] (to add carriage returns)\n", stderr);
  261.     exit(EXIT_FAILURE);
  262.   }
  263.   for ( ; optind < argc; optind++)
  264.   {
  265.     fn = argv[optind];
  266.     if (access(fn, 4))
  267.     {
  268.       err++;
  269.       perror2(program, fn);
  270.       continue;
  271.     }
  272.     if (stat(fn, &st))
  273.     {
  274.       err++;
  275.       perror2(program, fn);
  276.     }
  277.     ut.actime = st.st_atime;
  278.     ut.modtime = st.st_mtime;
  279.     if (crlf(fn, mode) != 0)
  280.     {
  281.       err++;
  282.       continue;
  283.     }
  284.     if (utime(fn, &ut))
  285.     {
  286.       err++;
  287.       perror2(program, fn);
  288.     }
  289.   }
  290.   if (err)
  291.   {
  292.     exit(EXIT_FAILURE);
  293.   }
  294.   exit(EXIT_SUCCESS);
  295.   return (0);
  296. }
  297.