/* $Id: word2x.cc,v 1.12 1997/04/13 05:53:11 dps Exp $ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#if HAVE_ALLOCA_H
#include <alloca.h>
#else /* Do not have alloca.h */
#ifdef _AIX
#pragma alloca
#else /* not _AIX */
extern "C" char *alloca(int);
#endif /* _AIX */
#endif /* HAVE_ALLOCA_H */
#endif /* __GNUC__ */

#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif /* HAVE_STRING_H */
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif /* HAVE_STRINGS_H */
#ifdef HAVE_TIME_H
#include <time.h>
#endif /* HAVE_TIME_H */
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif /* HAVE_SYS_TIME_H */
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif /* HAVE_CTYPE_H */
#include "getopt.h"
#include "interface.h"
#include "lib.h"
#include "strip.h"

#ifndef N
#define N(x) (sizeof(x)/sizeof(x[0]))
#endif

extern docfmt txtfmt, latexfmt, htmlfmt;

/* postfix test */
static int postfix(const char *s, const char *t)
{
   unsigned int n;

   n=strlen(t);
   if (strlen(s)<=n)
       return 0;
   return (strcasecmp(s+strlen(s)-n, t)==0) ? 1 : 0;
}

/*
* open file with .doc or .DOC tacked on the end if the filename alone
* does not exist
*/
static FILE *open_file(const char *f)
{
   char *s;
   FILE *r;

   if ((r=fopen(f, "r"))!=NULL)
       return r;

   if ((s=(char *) malloc(strlen(f)+4))==NULL)
   {
       fprintf(stderr,"word2x: skipping %s due to malloc failure\n", f);
       return NULL;
   }
   strcpy(s, f);
   strcat(s, ".doc");

   if ((r=fopen(s, "r"))==NULL)
   {
       free(s);
       return r;
   }

   strcpy(s+strlen(f), ".DOC");
   r=fopen(s, "r");
   free(s);

   return r;
}


/* Just read the files and pass the results on... */
static void convert(istream *f, FILE *out, const struct docfmt *fmt)
{
   const tok_seq::tok *d;
   int i;
   void *dptr;
   tok_seq rd(f);

   dptr=fmt->new_state();
   while ((d=rd.read_token())!=NULL)
   {
       i=d->tokval;

#ifndef C_ALLOCA
       alloca(0);
#endif

       if (i<NFUNCS && d->end==tok_seq::tok::TOK_START)
       {
           (fmt->f[i]).start(d, fmt, out, dptr);
       }
       else
       {
           (fmt->f[i]).end(d, fmt, out, dptr);
       }
   }
   fmt->free_state(dptr);
}

static const char *outname(const char *in, const char *ext)
{
   char *r, *s;
   int adj;

   if (postfix(in, ".doc"))
       adj=4;
   else
       adj=0;

   if ((r=(char *) malloc(strlen(in)+strlen(ext)-adj+1))==NULL)
       return NULL;
   strcpy(r, in);
   s=r+strlen(r)-adj;
   strcpy(s, ext);

   return r;
}

int main(int argc, const char **argv)
{
   static const struct
   {
       const char *name;
       char *(*fmt)(time_t);
   } dates[]=
   {
       { "uk", uk_date },
       { "british", uk_date },
       { "us", us_date },
       { "de", de_date },
       { "deHTML", deHTML_date },
       { "deL1", deL1_date },
   };
   static const struct
   {
       const char *name;
       const char *ext;
       const docfmt *fmt;
   } formats[]=
   {
       { "text", ".txt", &txtfmt },
       { "latex", ".tex", &latexfmt },
       { "html", ".html", &htmlfmt },
   };
#if !defined(NO_LONG_OPTS)
   static const struct option lopts[]=
   {
       { "version", 0, NULL, 'V' },
       { "help", 0, NULL, 'h' },
       { "format", 1, NULL, 'f' },
       { "width", 0, NULL,  'w' },
       { "dates", 0, NULL, 'd' },
       { "verbose", 0, NULL, 'v' },
       { "quiet", 0, NULL, 'q' },
       { "pagebreak", 0, NULL, 'p' },
   };
#endif

   char *(*dfmt)(time_t);
   FILE *in, *out;
   docfmt fmt;
   int c, i, opt_index, n, wd;
   const char *s,*t, *ext;
   int verbose=0, name_alloced, res;

   struct
   {
       unsigned new_pages:1;
   } flags={ 0 };
   res=0;                      // Return code 0
   fmt=*(formats[0].fmt);      // Set default format
   dfmt=dates[0].fmt;          // Set default date format
   wd=fmt.maxline;             // Set default width
   ext=formats[0].ext;         // Set default extension

   while ((c=getopt_long(argc, (char *const *) argv, "Vhpvqf:w:d:",
                         lopts, &opt_index))!=-1)
   {
       switch(c)
       {
       case 'V':                       // Print version and exit
           fputs("word2x 0.005\n", stderr);
           return 0;

       case 'p':
           flags.new_pages=1;
           break;

       case 'h':                       // Help
           fputs("Usage: word2x [-f <output format>] [--dates <date format>]"
                 " [-w <line length>]\n"
                 "              <infile> [<outfile>]\n"
                 "Supported date formats: ", stderr);
           for (i=0; i<(int) N(dates); i++)
           {
               if (i!=0)
                   fputs(", ", stderr);
               fputs(dates[i].name, stderr);
           }
           fputs("\nSupported output formats: ", stderr);
           for (i=0; i<(int) N(formats); i++)
           {
               if (i!=0)
                   fputs(", ", stderr);
               fputs(formats[i].name, stderr);
           }
           fputc('\n', stderr);
           return 0;

       case 'v':                       // Verbose mode
           verbose=1;
           break;

       case 'q':                       // Queit mode
           verbose=0;
           break;

       case 'w':                       // Width
           n=0;
           if (*optarg=='\0')
           {
               fputs("-w requires a number\n", stderr);
               break;
           }
           for (s=optarg; *s; s++)
           {
               if (!isdigit(*s))
               {
                   res=1;
                   fputs("-w requires a number\n", stderr);
                   break;
               }
               n=n*10+(*s-'0');
           }
           if (*s=='\0')
               wd=n;
           break;

       case 'd':                       // Date format
           for (n=-1, i=0; i<(int) N(dates); i++)
           {
               if (strcasecmp(dates[i].name, optarg)==0)
               {
                   n=i;
                   break;
               }
           }
           if (n==-1)
           {
               res=1;
               fprintf(stderr, "%s is not a known date format\n", optarg);
           }
           else
               dfmt=dates[i].fmt;
           break;

       case 'f':                       // Output format
           for (n=-1, i=0; i<(int) N(formats); i++)
           {
               if (strcasecmp(formats[i].name, optarg)==0)
               {
                   n=i;
                   break;
               }
           }
           if (n==-1)
           {
               res=1;
               fprintf(stderr, "%s is not a known output format\n", optarg);
           }
           else
           {
               fmt=*(formats[i].fmt);
               ext=formats[i].ext;
           }
           break;

       case '?':
           break;

       default:
           abort();
       }
   }

   /* Make sure we have a filename */
   if (optind==argc)
   {
       fputs("word2x: filename required (can not handle stdin)\n", stderr);
       return 1;
   }

   /* Stop if invalid switches */
   if (res!=0)
       return res;

   /* Set line width and date format */
   fmt.date=dfmt;
   fmt.maxline=wd;
   fmt.flags.new_pages=flags.new_pages;

   /* Loop through files */
   for (i=optind; i<argc; i++)
   {
       s=argv[i];
       if (i==argc-1 || postfix(argv[i+1],".doc"))
       {
           /* Generate output file name */
           if ((t=outname(argv[i], ext))==NULL)
           {
               fprintf(stderr,
                       "word2x: skipping %s due to allocation failure\n",
                       s);
               continue;
           }
           name_alloced=1;
       }
       else
       {
           t=argv[++i];
           name_alloced=0;
       }

       /* Open input file */
       if ((in=open_file(s))==NULL)
       {
           if (name_alloced)
               free((void *) t);
           fprintf(stderr, "Could not open %s\n", s);
           res=1;
           continue;
       }

       /* Open output file */
       if (strcmp(t,"-")==0)
       {
           out=stdout;
           t="standard output";
       }
       else
       {
           if ((out=fopen(t, "w"))==NULL)
           {
               fprintf(stderr, "Could not open %s\n", t);
               if (name_alloced)
                   free((void *) t);
               fclose(in);
               res=1;
               continue;
           }
       }

       fclose(in);
       word_junk_filter filt(s);
       istream in(&filt);

       /* Finally do something */
       if (verbose)
           fprintf(stderr, "Converting %s to %s\n", s, t);
       convert(&in, out, &fmt);

       /* Junk filter and istream go out of scope here */
   }

   return res;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.