Return to cvtmail.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / etc

Annotation of 43BSD/contrib/emacs/etc/cvtmail.c, revision 1.1.1.1

1.1       root        1: /* Copyright (C) 1985 Free Software Foundation
                      2: This file is part of GNU Emacs.
                      3: 
                      4: GNU Emacs is distributed in the hope that it will be useful,
                      5: but without any warranty.  No author or distributor
                      6: accepts responsibility to anyone for the consequences of using it
                      7: or for whether it serves any particular purpose or works at all,
                      8: unless he says so in writing.
                      9: 
                     10: Everyone is granted permission to copy, modify and redistribute
                     11: GNU Emacs, but only under the conditions described in the
                     12: document "GNU Emacs copying permission notice".   An exact copy
                     13: of the document is supposed to have been given to you along with
                     14: GNU Emacs so that you can know how you may redistribute it all.
                     15: It should be in a file named COPYING.  Among other things, the
                     16: copyright notice and this notice must be preserved on all copies.  */
                     17: 
                     18: /* cvtmail:
                     19:  * Program to convert oldstyle goslings emacs mail directories into
                     20:  * gnu-rmail format.  Program expects a directory called Messages to
                     21:  * exist in your home directory, containing individual mail messages in
                     22:  * separate files in the standard gosling emacs mail reader format.
                     23:  *
                     24:  * Program takes one argument: an output file.  THis file will contain
                     25:  * all the messages in Messages directory, in berkeley mail format.
                     26:  * If no output file is mentioned, messages are put in ~/OMAIL.
                     27:  *
                     28:  * In order to get rmail to read the messages, the resulting file must
                     29:  * be mv'ed to ~/mbox, and then have rmail invoked on them.
                     30:  * 
                     31:  * Author: Larry Kolodney, 1985
                     32: 
                     33:  * RMS, 2 Sept 85: Removed fix maximums on file name sizes.
                     34:  */
                     35: 
                     36: 
                     37: #include <stdio.h>
                     38: 
                     39: 
                     40: main (argc, argv)
                     41:      int argc;
                     42:      char *argv[];
                     43: {
                     44:   char *hd;
                     45:   char *md;
                     46:   char *mdd;
                     47:   char *mfile;
                     48:   char *cf;
                     49:   int cflen;
                     50:   FILE *mddf;
                     51:   FILE *mfilef;
                     52:   FILE *cff;
                     53:   char pre[10], post[100];
                     54:   char name[14];
                     55:   int c;
                     56: 
                     57:   hd = (char *) getenv ("HOME");
                     58: 
                     59:   md = (char *) xmalloc (strlen (hd) + 10);
                     60:   strcpy (md, hd);
                     61:   strcat (md, "/Messages");
                     62: 
                     63:   mdd = (char *) xmalloc (strlen (md) + 11);
                     64:   strcpy (mdd, md);
                     65:   strcat (mdd, "/Directory");
                     66: 
                     67:   cflen = 100;
                     68:   cf = (char *) xmalloc (cflen);
                     69: 
                     70:   mddf = fopen (mdd, "r");
                     71:   if (argc > 1)
                     72:     mfilef = fopen (argv[1], "w");
                     73:   else
                     74:     {
                     75:       mfile = (char *) xmalloc (strlen (hd) + 7);
                     76:       strcpy (mfile, hd);
                     77:       strcat (mfile, "/OMAIL");
                     78:       mfilef = fopen (mfile, "w");
                     79:     }
                     80:   skip_to_lf (mddf);
                     81:   while (fscanf (mddf, "%4c%14[0123456789]", pre, name) != EOF)
                     82:     {
                     83:       if (cflen < strlen (md) + strlen (name) + 2)
                     84:        {
                     85:          cflen = strlen (md) + strlen (name) + 2;
                     86:          cf = (char *) xrealloc (cf, cflen);
                     87:        }
                     88:       strcpy (cf, md);
                     89:       strcat (cf,"/");
                     90:       strcat (cf, name);
                     91:       cff = fopen (cf, "r");
                     92:       while ((c = getc(cff)) != EOF)
                     93:        putc (c, mfilef);
                     94:       putc ('\n', mfilef);
                     95:       skip_to_lf (mddf);
                     96:      fclose (cff);
                     97:     }
                     98:   fclose (mddf);
                     99:   fclose (mfilef);    
                    100:   return 0;
                    101: }
                    102: 
                    103: skip_to_lf (stream)
                    104:      FILE *stream;
                    105: {
                    106:   register int c;
                    107:   while ((c = getc(stream)) != '\n')
                    108:     ;
                    109: }
                    110: 
                    111: int
                    112: xmalloc (size)
                    113:      int size;
                    114: {
                    115:   int result = malloc (size);
                    116:   if (!result)
                    117:     fatal ("virtual memory exhausted", 0);
                    118:   return result;
                    119: }
                    120: 
                    121: int
                    122: xrealloc (ptr, size)
                    123:      char *ptr;
                    124:      int size;
                    125: {
                    126:   int result = realloc (ptr, size);
                    127:   if (!result)
                    128:     fatal ("virtual memory exhausted");
                    129:   return result;
                    130: }
                    131: 
                    132: /* Print error message and exit.  */
                    133: 
                    134: fatal (s1, s2)
                    135:      char *s1, *s2;
                    136: {
                    137:   error (s1, s2);
                    138:   exit (1);
                    139: }
                    140: 
                    141: error (s1, s2)
                    142:      char *s1, *s2;
                    143: {
                    144:   printf ("cvtmail: ");
                    145:   printf (s1, s2);
                    146:   printf ("\n");
                    147: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.