lib-src/b2m.c

   1 /*
   2  * b2m - a filter for Babyl -> Unix mail files
   3  * The copyright on this file has been disclaimed.
   4  *
   5  * usage:       b2m < babyl > mailbox
   6  *
   7  * I find this useful whenever I have to use a
   8  * system which - shock horror! - doesn't run
   9  * GNU Emacs. At least now I can read all my
  10  * GNU Emacs Babyl format mail files!
  11  *
  12  * it's not much but it's free!
  13  *
  14  *   Ed Wilkinson
  15  *   E.Wilkinson@massey.ac.nz
  16  *   Mon Nov 7 15:54:06 PDT 1988
  17  */
  18
  19 /* Made conformant to the GNU coding standards January, 1995
  20    by Francesco Potorti` <pot@cnuce.cnr.it>. */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 /* On some systems, Emacs defines static as nothing for the sake
  25    of unexec.  We don't want that here since we don't use unexec. */
  26 #undef static
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <time.h>
  31 #include <sys/types.h>
  32 #include <getopt.h>
  33 #ifdef MSDOS
  34 #include <fcntl.h>
  35 #endif
  36
  37 #undef TRUE
  38 #define TRUE    1
  39 #undef FALSE
  40 #define FALSE   0
  41
  42 #define streq(s,t)      (strcmp (s, t) == 0)
  43 #define strneq(s,t,n)   (strncmp (s, t, n) == 0)
  44
  45 typedef int logical;
  46
  47 #define TM_YEAR_BASE 1900
  48
  49 /* Nonzero if TM_YEAR is a struct tm's tm_year value that causes
  50    asctime to have well-defined behavior.  */
  51 #ifndef TM_YEAR_IN_ASCTIME_RANGE
  52 # define TM_YEAR_IN_ASCTIME_RANGE(tm_year) \
  53     (1000 - TM_YEAR_BASE <= (tm_year) && (tm_year) <= 9999 - TM_YEAR_BASE)
  54 #endif
  55
  56 /*
  57  * A `struct linebuffer' is a structure which holds a line of text.
  58  * `readline' reads a line from a stream into a linebuffer and works
  59  * regardless of the length of the line.
  60  */
  61 struct linebuffer
  62 {
  63   long size;
  64   char *buffer;
  65 };
  66
  67 extern char *strtok();
  68
  69 long *xmalloc (unsigned int size);
  70 long *xrealloc (char *ptr, unsigned int size);
  71 char *concat (char *s1, char *s2, char *s3);
  72 long readline (struct linebuffer *linebuffer, register FILE *stream);
  73 void fatal (char *message);
  74
  75 /*
  76  * xnew -- allocate storage.  SYNOPSIS: Type *xnew (int n, Type);
  77  */
  78 #define xnew(n, Type)   ((Type *) xmalloc ((n) * sizeof (Type)))
  79
  80
  81
  82 char *progname;
  83
  84 struct option longopts[] =
  85 {
  86   { "help",                     no_argument,       NULL,     'h'   },
  87   { "version",                  no_argument,       NULL,     'V'   },
  88   { 0 }
  89 };
  90
  91 extern int optind;
  92
  93 int
  94 main (argc, argv)
  95      int argc;
  96      char **argv;
  97 {
  98   logical labels_saved, printing, header, first, last_was_blank_line;
  99   time_t ltoday;
 100   struct tm *tm;
 101   char *labels, *p, *today;
 102   struct linebuffer data;
 103
 104 #ifdef MSDOS
 105   _fmode = O_BINARY;            /* all of files are treated as binary files */
 106 #if __DJGPP__ > 1
 107   if (!isatty (fileno (stdout)))
 108     setmode (fileno (stdout), O_BINARY);
 109   if (!isatty (fileno (stdin)))
 110     setmode (fileno (stdin), O_BINARY);
 111 #else /* not __DJGPP__ > 1 */
 112   (stdout)->_flag &= ~_IOTEXT;
 113   (stdin)->_flag &= ~_IOTEXT;
 114 #endif /* not __DJGPP__ > 1 */
 115 #endif
 116   progname = argv[0];
 117
 118   while (1)
 119     {
 120       int opt = getopt_long (argc, argv, "hV", longopts, 0);
 121       if (opt == EOF)
 122         break;
 123
 124       switch (opt)
 125         {
 126         case 'V':
 127           printf ("%s (GNU Emacs %s)\n", "b2m", VERSION);
 128           puts ("b2m is in the public domain.");
 129           exit (EXIT_SUCCESS);
 130
 131         case 'h':
 132           fprintf (stderr, "Usage: %s <babylmailbox >unixmailbox\n", progname);
 133           exit (EXIT_SUCCESS);
 134         }
 135     }
 136
 137   if (optind != argc)
 138     {
 139       fprintf (stderr, "Usage: %s <babylmailbox >unixmailbox\n", progname);
 140       exit (EXIT_SUCCESS);
 141     }
 142
 143   labels_saved = printing = header = last_was_blank_line = FALSE;
 144   first = TRUE;
 145   ltoday = time (0);
 146   /* Convert to a string, checking for out-of-range time stamps.
 147      Don't use 'ctime', as that might dump core if the hardware clock
 148      is set to a bizarre value.  */
 149   tm = localtime (&ltoday);
 150   if (! (tm && TM_YEAR_IN_ASCTIME_RANGE (tm->tm_year)
 151          && (today = asctime (tm))))
 152     fatal ("current time is out of range");
 153   data.size = 200;
 154   data.buffer = xnew (200, char);
 155
 156   if (readline (&data, stdin) == 0
 157       || !strneq (data.buffer, "BABYL OPTIONS:", 14))
 158     fatal ("standard input is not a Babyl mailfile.");
 159
 160   while (readline (&data, stdin) > 0)
 161     {
 162       if (streq (data.buffer, "*** EOOH ***") && !printing)
 163         {
 164           printing = header = TRUE;
 165           printf ("From \"Babyl to mail by %s\" %s", progname, today);
 166           continue;
 167         }
 168
 169       if (data.buffer[0] == '\037')
 170         {
 171           if (data.buffer[1] == '\0')
 172             continue;
 173           else if (data.buffer[1] == '\f')
 174             {
 175               if (first)
 176                 first = FALSE;
 177               else if (! last_was_blank_line)
 178                 puts("");
 179               /* Save labels. */
 180               readline (&data, stdin);
 181               p = strtok (data.buffer, " ,\r\n\t");
 182               labels = "X-Babyl-Labels: ";
 183
 184               while ((p = strtok (NULL, " ,\r\n\t")))
 185                 labels = concat (labels, p, ", ");
 186
 187               p = &labels[strlen (labels) - 2];
 188               if (*p == ',')
 189                 *p = '\0';
 190               printing = header = FALSE;
 191               labels_saved = TRUE;
 192               continue;
 193             }
 194         }
 195
 196       if ((data.buffer[0] == '\0') && header)
 197         {
 198           header = FALSE;
 199           if (labels_saved)
 200             puts (labels);
 201         }
 202
 203       if (printing)
 204         {
 205           puts (data.buffer);
 206           if (data.buffer[0] == '\0')
 207             last_was_blank_line = TRUE;
 208           else
 209             last_was_blank_line = FALSE;
 210         }
 211     }
 212
 213   return EXIT_SUCCESS;
 214 }
 215
 216
 217
 218 /*
 219  * Return a newly-allocated string whose contents
 220  * concatenate those of s1, s2, s3.
 221  */
 222 char *
 223 concat (s1, s2, s3)
 224      char *s1, *s2, *s3;
 225 {
 226   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 227   char *result = xnew (len1 + len2 + len3 + 1, char);
 228
 229   strcpy (result, s1);
 230   strcpy (result + len1, s2);
 231   strcpy (result + len1 + len2, s3);
 232   result[len1 + len2 + len3] = '\0';
 233
 234   return result;
 235 }
 236
 237 /*
 238  * Read a line of text from `stream' into `linebuffer'.
 239  * Return the number of characters read from `stream',
 240  * which is the length of the line including the newline, if any.
 241  */
 242 long
 243 readline (linebuffer, stream)
 244      struct linebuffer *linebuffer;
 245      register FILE *stream;
 246 {
 247   char *buffer = linebuffer->buffer;
 248   register char *p = linebuffer->buffer;
 249   register char *pend;
 250   int chars_deleted;
 251
 252   pend = p + linebuffer->size;  /* Separate to avoid 386/IX compiler bug.  */
 253
 254   while (1)
 255     {
 256       register int c = getc (stream);
 257       if (p == pend)
 258         {
 259           linebuffer->size *= 2;
 260           buffer = (char *) xrealloc (buffer, linebuffer->size);
 261           p += buffer - linebuffer->buffer;
 262           pend = buffer + linebuffer->size;
 263           linebuffer->buffer = buffer;
 264         }
 265       if (c == EOF)
 266         {
 267           *p = '\0';
 268           chars_deleted = 0;
 269           break;
 270         }
 271       if (c == '\n')
 272         {
 273           if (p > buffer && p[-1] == '\r')
 274             {
 275               *--p = '\0';
 276               chars_deleted = 2;
 277             }
 278           else
 279             {
 280               *p = '\0';
 281               chars_deleted = 1;
 282             }
 283           break;
 284         }
 285       *p++ = c;
 286     }
 287
 288   return (p - buffer + chars_deleted);
 289 }
 290
 291 /*
 292  * Like malloc but get fatal error if memory is exhausted.
 293  */
 294 long *
 295 xmalloc (size)
 296      unsigned int size;
 297 {
 298   long *result = (long *) malloc (size);
 299   if (result == NULL)
 300     fatal ("virtual memory exhausted");
 301   return result;
 302 }
 303
 304 long *
 305 xrealloc (ptr, size)
 306      char *ptr;
 307      unsigned int size;
 308 {
 309   long *result = (long *) realloc (ptr, size);
 310   if (result == NULL)
 311     fatal ("virtual memory exhausted");
 312   return result;
 313 }
 314
 315 void
 316 fatal (message)
 317      char *message;
 318 {
 319   fprintf (stderr, "%s: %s\n", progname, message);
 320   exit (EXIT_FAILURE);
 321 }
 322
 323 /* arch-tag: 5a3ad2af-a802-408f-83cc-e7cf5e98653e
 324    (do not change this comment) */
 325
 326 /* b2m.c ends here */