[BACK]Return to preconv.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/preconv.c between version 1.5 and 1.10

version 1.5, 2011/07/24 18:15:14 version 1.10, 2014/10/26 18:22:51
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2014 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 14 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
 #ifdef HAVE_MMAP  #include <sys/types.h>
 #include <sys/stat.h>  
 #include <sys/mman.h>  
 #endif  
   
 #include <assert.h>  
 #include <fcntl.h>  
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include "mandoc.h"
   #include "libmandoc.h"
   
 /*  int
  * The read_whole_file() and resize_buf() functions are copied from  preconv_encode(struct buf *ib, struct buf *ob, int *filenc)
  * read.c, including all dependency code (MAP_FILE, etc.).  
  */  
   
 #ifndef MAP_FILE  
 #define MAP_FILE        0  
 #endif  
   
 enum    enc {  
         ENC_UTF_8, /* UTF-8 */  
         ENC_US_ASCII, /* US-ASCII */  
         ENC_LATIN_1, /* Latin-1 */  
         ENC__MAX  
 };  
   
 struct  buf {  
         char             *buf; /* binary input buffer */  
         size_t            sz; /* size of binary buffer */  
         size_t            offs; /* starting buffer offset */  
 };  
   
 struct  encode {  
         const char       *name;  
         int             (*conv)(const struct buf *);  
 };  
   
 static  int      cue_enc(const struct buf *, size_t *, enum enc *);  
 static  int      conv_latin_1(const struct buf *);  
 static  int      conv_us_ascii(const struct buf *);  
 static  int      conv_utf_8(const struct buf *);  
 static  int      read_whole_file(const char *, int,  
                         struct buf *, int *);  
 static  void     resize_buf(struct buf *, size_t);  
 static  void     usage(void);  
   
 static  const struct encode encs[ENC__MAX] = {  
         { "utf-8", conv_utf_8 }, /* ENC_UTF_8 */  
         { "us-ascii", conv_us_ascii }, /* ENC_US_ASCII */  
         { "latin-1", conv_latin_1 }, /* ENC_LATIN_1 */  
 };  
   
 static  const char       *progname;  
   
 static void  
 usage(void)  
 {  {
   
         fprintf(stderr, "usage: %s "  
                         "[-D enc] "  
                         "[-e ENC] "  
                         "[file]\n", progname);  
 }  
   
 static int  
 conv_latin_1(const struct buf *b)  
 {  
         size_t           i;          size_t           i;
         unsigned char    cu;          const long       one = 1L;
         const char      *cp;  
   
         cp = b->buf + (int)b->offs;  
   
         /*  
          * Latin-1 falls into the first 256 code-points of Unicode, so  
          * there's no need for any sort of translation.  Just make the  
          * 8-bit characters use the Unicode escape.  
          * Note that binary values 128 < v < 160 are passed through  
          * unmodified to mandoc.  
          */  
   
         for (i = b->offs; i < b->sz; i++) {  
                 cu = (unsigned char)*cp++;  
                 cu < 160U ? putchar(cu) : printf("\\[u%.4X]", cu);  
         }  
   
         return(1);  
 }  
   
 static int  
 conv_us_ascii(const struct buf *b)  
 {  
   
         /*  
          * US-ASCII has no conversion since it falls into the first 128  
          * bytes of Unicode.  
          */  
   
         fwrite(b->buf, 1, b->sz, stdout);  
         return(1);  
 }  
   
 static int  
 conv_utf_8(const struct buf *b)  
 {  
         int              state, be;          int              state, be;
         unsigned int     accum;          unsigned int     accum;
         size_t           i;  
         unsigned char    cu;          unsigned char    cu;
         const char      *cp;  
         const long       one = 1L;  
   
         cp = b->buf + (int)b->offs;          if ( ! (*filenc & MPARSE_UTF8))
                   goto latin;
   
         state = 0;          state = 0;
         accum = 0U;          accum = 0U;
         be = 0;          be = 0;
Line 142  conv_utf_8(const struct buf *b)
Line 45  conv_utf_8(const struct buf *b)
         if ( ! (*((const char *)(&one))))          if ( ! (*((const char *)(&one))))
                 be = 1;                  be = 1;
   
         for (i = b->offs; i < b->sz; i++) {          for (i = ib->offs; i < ib->sz; i++) {
                 cu = (unsigned char)*cp++;                  cu = ib->buf[i];
                 if (state) {                  if (state) {
                         if ( ! (cu & 128) || (cu & 64)) {                          if ( ! (cu & 128) || (cu & 64)) {
                                 /* Bad sequence header. */                                  /* Bad sequence header. */
                                 return(0);                                  break;
                         }                          }
   
                         /* Accept only legitimate bit patterns. */                          /* Accept only legitimate bit patterns. */
   
                         if (cu > 191 || cu < 128) {                          if (cu > 191 || cu < 128) {
                                 /* Bad in-sequence bits. */                                  /* Bad in-sequence bits. */
                                 return(0);                                  break;
                         }                          }
   
                         accum |= (cu & 63) << --state * 6;                          accum |= (cu & 63) << --state * 6;
   
                           if (state)
                                   continue;
   
                         /*                          /*
                          * Accum is held in little-endian order as                           * Accum is held in little-endian order as
                          * stipulated by the UTF-8 sequence coding.  We                           * stipulated by the UTF-8 sequence coding.  We
Line 166  conv_utf_8(const struct buf *b)
Line 72  conv_utf_8(const struct buf *b)
                          * architecture requires it.                           * architecture requires it.
                          */                           */
   
                         if (0 == state && be)                          if (be)
                                 accum = (accum >> 24) |                                  accum = (accum >> 24) |
                                         ((accum << 8) & 0x00FF0000) |                                          ((accum << 8) & 0x00FF0000) |
                                         ((accum >> 8) & 0x0000FF00) |                                          ((accum >> 8) & 0x0000FF00) |
                                         (accum << 24);                                          (accum << 24);
   
                         if (0 == state) {                          if (accum < 0x80)
                                 accum < 128U ? putchar(accum) :                                  ob->buf[ob->offs++] = accum;
                                         printf("\\[u%.4X]", accum);                          else
                                 accum = 0U;                                  ob->offs += snprintf(ob->buf + ob->offs,
                         }                                      11, "\\[u%.4X]", accum);
                 } else if (cu & (1 << 7)) {                          ib->offs = i + 1;
                           *filenc &= ~MPARSE_LATIN1;
                           return(1);
                   } else {
                         /*                          /*
                          * Entering a UTF-8 state:  if we encounter a                           * Entering a UTF-8 state:  if we encounter a
                          * UTF-8 bitmask, calculate the expected UTF-8                           * UTF-8 bitmask, calculate the expected UTF-8
Line 189  conv_utf_8(const struct buf *b)
Line 98  conv_utf_8(const struct buf *b)
   
                         /* Accept only legitimate bit patterns. */                          /* Accept only legitimate bit patterns. */
   
                         switch (state) {                          switch (state--) {
                         case (4):                          case (4):
                                 if (cu <= 244 && cu >= 240) {                                  if (cu <= 244 && cu >= 240) {
                                         accum = (cu & 7) << 18;                                          accum = (cu & 7) << 18;
                                         break;                                          continue;
                                 }                                  }
                                 /* Bad 4-sequence start bits. */                                  /* Bad 4-sequence start bits. */
                                 return(0);                                  break;
                         case (3):                          case (3):
                                 if (cu <= 239 && cu >= 224) {                                  if (cu <= 239 && cu >= 224) {
                                         accum = (cu & 15) << 12;                                          accum = (cu & 15) << 12;
                                         break;                                          continue;
                                 }                                  }
                                 /* Bad 3-sequence start bits. */                                  /* Bad 3-sequence start bits. */
                                 return(0);                                  break;
                         case (2):                          case (2):
                                 if (cu <= 223 && cu >= 194) {                                  if (cu <= 223 && cu >= 194) {
                                         accum = (cu & 31) << 6;                                          accum = (cu & 31) << 6;
                                         break;                                          continue;
                                 }                                  }
                                 /* Bad 2-sequence start bits. */                                  /* Bad 2-sequence start bits. */
                                 return(0);                                  break;
                         default:                          default:
                                 /* Bad sequence bit mask. */                                  /* Bad sequence bit mask. */
                                 return(0);                                  break;
                         }                          }
                         state--;                          break;
                 } else                  }
                         putchar(cu);  
         }          }
   
         if (0 != state) {          /* FALLTHROUGH: Invalid or incomplete UTF-8 sequence. */
                 /* Bad trailing bits. */  
                 return(0);  
         }  
   
         return(1);  latin:
 }          if ( ! (*filenc & MPARSE_LATIN1))
   
 static void  
 resize_buf(struct buf *buf, size_t initial)  
 {  
   
         buf->sz = buf->sz > initial / 2 ?  
                 2 * buf->sz : initial;  
   
         buf->buf = realloc(buf->buf, buf->sz);  
         if (NULL == buf->buf) {  
                 perror(NULL);  
                 exit(EXIT_FAILURE);  
         }  
 }  
   
 static int  
 read_whole_file(const char *f, int fd,  
                 struct buf *fb, int *with_mmap)  
 {  
         size_t           off;  
         ssize_t          ssz;  
   
 #ifdef  HAVE_MMAP  
         struct stat      st;  
         if (-1 == fstat(fd, &st)) {  
                 perror(f);  
                 return(0);                  return(0);
         }  
   
         /*          ob->offs += snprintf(ob->buf + ob->offs, 11,
          * If we're a regular file, try just reading in the whole entry              "\\[u%.4X]", (unsigned char)ib->buf[ib->offs++]);
          * via mmap().  This is faster than reading it into blocks, and  
          * since each file is only a few bytes to begin with, I'm not  
          * concerned that this is going to tank any machines.  
          */  
   
         if (S_ISREG(st.st_mode) && st.st_size >= (1U << 31)) {          *filenc &= ~MPARSE_UTF8;
                 fprintf(stderr, "%s: input too large\n", f);          return(1);
                 return(0);  
         }  
   
         if (S_ISREG(st.st_mode)) {  
                 *with_mmap = 1;  
                 fb->sz = (size_t)st.st_size;  
                 fb->buf = mmap(NULL, fb->sz, PROT_READ,  
                                 MAP_FILE|MAP_SHARED, fd, 0);  
                 if (fb->buf != MAP_FAILED)  
                         return(1);  
         }  
 #endif  
   
         /*  
          * If this isn't a regular file (like, say, stdin), then we must  
          * go the old way and just read things in bit by bit.  
          */  
   
         *with_mmap = 0;  
         off = 0;  
         fb->sz = 0;  
         fb->buf = NULL;  
         for (;;) {  
                 if (off == fb->sz && fb->sz == (1U << 31)) {  
                         fprintf(stderr, "%s: input too large\n", f);  
                         break;  
                 }  
   
                 if (off == fb->sz)  
                         resize_buf(fb, 65536);  
   
                 ssz = read(fd, fb->buf + (int)off, fb->sz - off);  
                 if (ssz == 0) {  
                         fb->sz = off;  
                         return(1);  
                 }  
                 if (ssz == -1) {  
                         perror(f);  
                         break;  
                 }  
                 off += (size_t)ssz;  
         }  
   
         free(fb->buf);  
         fb->buf = NULL;  
         return(0);  
 }  }
   
 static int  int
 cue_enc(const struct buf *b, size_t *offs, enum enc *enc)  preconv_cue(const struct buf *b)
 {  {
         const char      *ln, *eoln, *eoph;          const char      *ln, *eoln, *eoph;
         size_t           sz, phsz, nsz;          size_t           sz, phsz;
         int              i;  
   
         ln = b->buf + (int)*offs;          ln = b->buf + b->offs;
         sz = b->sz - *offs;          sz = b->sz - b->offs;
   
         /* Look for the end-of-line. */          /* Look for the end-of-line. */
   
         if (NULL == (eoln = memchr(ln, '\n', sz)))          if (NULL == (eoln = memchr(ln, '\n', sz)))
                 return(-1);                  eoln = ln + sz;
   
         /* Set next-line marker. */  
   
         *offs = (size_t)((eoln + 1) - b->buf);  
   
         /* Check if we have the correct header/trailer. */          /* Check if we have the correct header/trailer. */
   
         if ((sz = (size_t)(eoln - ln)) < 10 ||          if ((sz = (size_t)(eoln - ln)) < 10 ||
                         memcmp(ln, ".\\\" -*-", 7) ||              memcmp(ln, ".\\\" -*-", 7) || memcmp(eoln - 3, "-*-", 3))
                         memcmp(eoln - 3, "-*-", 3))                  return(MPARSE_UTF8 | MPARSE_LATIN1);
                 return(0);  
   
         /* Move after the header and adjust for the trailer. */          /* Move after the header and adjust for the trailer. */
   
Line 361  cue_enc(const struct buf *b, size_t *offs, enum enc *e
Line 183  cue_enc(const struct buf *b, size_t *offs, enum enc *e
   
                 /* Only account for the "coding" phrase. */                  /* Only account for the "coding" phrase. */
   
                 if ((phsz = (size_t)(eoph - ln)) < 7 ||                  if ((phsz = eoph - ln) < 7 ||
                                 strncasecmp(ln, "coding:", 7)) {                      strncasecmp(ln, "coding:", 7)) {
                         sz -= phsz;                          sz -= phsz;
                         ln += phsz;                          ln += phsz;
                         continue;                          continue;
Line 376  cue_enc(const struct buf *b, size_t *offs, enum enc *e
Line 198  cue_enc(const struct buf *b, size_t *offs, enum enc *e
                         sz--;                          sz--;
                 }                  }
                 if (0 == sz)                  if (0 == sz)
                         break;                          return(0);
   
                 /* Check us against known encodings. */                  /* Check us against known encodings. */
   
                 for (i = 0; i < (int)ENC__MAX; i++) {                  if (phsz > 4 && !strncasecmp(ln, "utf-8", 5))
                         nsz = strlen(encs[i].name);                          return(MPARSE_UTF8);
                         if (phsz < nsz)                  if (phsz > 10 && !strncasecmp(ln, "iso-latin-1", 11))
                                 continue;                          return(MPARSE_LATIN1);
                         if (strncasecmp(ln, encs[i].name, nsz))                  return(0);
                                 continue;  
   
                         *enc = (enum enc)i;  
                         return(1);  
                 }  
   
                 /* Unknown encoding. */  
   
                 *enc = ENC__MAX;  
                 return(1);  
         }          }
           return(MPARSE_UTF8 | MPARSE_LATIN1);
         return(0);  
 }  
   
 int  
 main(int argc, char *argv[])  
 {  
         int              i, ch, map, fd, rc;  
         struct buf       b;  
         const char      *fn;  
         enum enc         enc, def;  
         unsigned char    bom[3] = { 0xEF, 0xBB, 0xBF };  
         size_t           offs;  
         extern int       optind;  
         extern char     *optarg;  
   
         progname = strrchr(argv[0], '/');  
         if (progname == NULL)  
                 progname = argv[0];  
         else  
                 ++progname;  
   
         fn = "<stdin>";  
         fd = STDIN_FILENO;  
         rc = EXIT_FAILURE;  
         enc = def = ENC__MAX;  
         map = 0;  
   
         memset(&b, 0, sizeof(struct buf));  
   
         while (-1 != (ch = getopt(argc, argv, "D:e:rdvh")))  
                 switch (ch) {  
                 case ('D'):  
                         /* FALLTHROUGH */  
                 case ('e'):  
                         for (i = 0; i < (int)ENC__MAX; i++) {  
                                 if (strcasecmp(optarg, encs[i].name))  
                                         continue;  
                                 break;  
                         }  
                         if (i < (int)ENC__MAX) {  
                                 if ('D' == ch)  
                                         def = (enum enc)i;  
                                 else  
                                         enc = (enum enc)i;  
                                 break;  
                         }  
   
                         fprintf(stderr, "%s: Bad encoding\n", optarg);  
                         return(EXIT_FAILURE);  
                 case ('r'):  
                         /* FALLTHROUGH */  
                 case ('d'):  
                         /* FALLTHROUGH */  
                 case ('v'):  
                         /* Compatibility with GNU preconv. */  
                         break;  
                 case ('h'):  
                         /* Compatibility with GNU preconv. */  
                         /* FALLTHROUGH */  
                 default:  
                         usage();  
                         return(EXIT_FAILURE);  
                 }  
   
         argc -= optind;  
         argv += optind;  
   
         /*  
          * Open and read the first argument on the command-line.  
          * If we don't have one, we default to stdin.  
          */  
   
         if (argc > 0) {  
                 fn = *argv;  
                 fd = open(fn, O_RDONLY, 0);  
                 if (-1 == fd) {  
                         perror(fn);  
                         return(EXIT_FAILURE);  
                 }  
         }  
   
         if ( ! read_whole_file(fn, fd, &b, &map))  
                 goto out;  
   
         /* Try to read the UTF-8 BOM. */  
   
         if (ENC__MAX == enc)  
                 if (b.sz > 3 && 0 == memcmp(b.buf, bom, 3)) {  
                         b.offs = 3;  
                         enc = ENC_UTF_8;  
                 }  
   
         /* Try reading from the "-*-" cue. */  
   
         if (ENC__MAX == enc) {  
                 offs = b.offs;  
                 ch = cue_enc(&b, &offs, &enc);  
                 if (0 == ch)  
                         ch = cue_enc(&b, &offs, &enc);  
         }  
   
         /*  
          * No encoding has been detected.  
          * Thus, we either fall into our default encoder, if specified,  
          * or use Latin-1 if all else fails.  
          */  
   
         if (ENC__MAX == enc)  
                 enc = ENC__MAX == def ? ENC_LATIN_1 : def;  
   
         if ( ! (*encs[(int)enc].conv)(&b)) {  
                 fprintf(stderr, "%s: Bad encoding\n", fn);  
                 goto out;  
         }  
   
         rc = EXIT_SUCCESS;  
 out:  
 #ifdef  HAVE_MMAP  
         if (map)  
                 munmap(b.buf, b.sz);  
         else  
 #endif  
                 free(b.buf);  
   
         if (fd > STDIN_FILENO)  
                 close(fd);  
   
         return(rc);  
 }  }

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.10

CVSweb