libextractor

dvi_extractor.c (41973B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2002, 2003, 2004, 2012, 2017, 2019 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/dvi_extractor.c
  * @brief plugin to support DVI files (from LaTeX)
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "extractor.h"
 #include "fulltext.h"
 #include "pagelayout.h"
 #include <math.h>
 
 
 /**
  * Pair of a PostScipt prefix and the corresponding LE type.
  */
 struct Matches
 {
   /**
    * Prefix in the PS map.
    */
   const char *text;
 
   /**
    * Corresponding LE type.
    */
   enum EXTRACTOR_MetaType type;
 };
 
 
 /**
  * Map from PS names to LE types.
  */
 static struct Matches tmap[] = {
   { "/Title (",    EXTRACTOR_METATYPE_TITLE },
   { "/Subject (",  EXTRACTOR_METATYPE_SUBJECT },
   { "/Author (",   EXTRACTOR_METATYPE_AUTHOR_NAME },
   { "/Keywords (", EXTRACTOR_METATYPE_KEYWORDS },
   { "/Creator (",  EXTRACTOR_METATYPE_CREATED_BY_SOFTWARE },
   { "/Producer (", EXTRACTOR_METATYPE_PRODUCED_BY_SOFTWARE },
   { NULL, 0 }
 };
 
 
 /**
  * Parse a "ZZZ" tag.  Specifically, the data may contain a
  * postscript dictionary with metadata.
  *
  * @param data overall input stream
  * @param pos where in data is the zzz data
  * @param len how many bytes from 'pos' does the zzz data extend?
  * @param proc function to call with meta data found
  * @param proc_cls closure for proc
  * @return 0 to continue to extract, 1 to stop
  */
 static int
 parseZZZ (const char *data,
           size_t pos, size_t len,
           EXTRACTOR_MetaDataProcessor proc,
           void *proc_cls)
 {
   size_t slen;
   size_t end;
   unsigned int i;
 
   end = pos + len;
   slen = strlen ("ps:SDict begin [");
   if ( (len <= slen) ||
        (0 != strncmp ("ps:SDict begin [ ", &data[pos], slen)) )
     return 0;
   pos += slen;
   while (pos < end)
   {
     for (i = 0; NULL != tmap[i].text; i++)
     {
       slen = strlen (tmap[i].text);
       if ( (pos + slen > end) ||
            (0 != strncmp (&data[pos], tmap[i].text, slen)) )
         continue;
       pos += slen;
       slen = pos;
       while ((slen < end) && (data[slen] != ')'))
         slen++;
       slen = slen - pos;
       {
         char value[slen + 1];
 
         value[slen] = '\0';
         memcpy (value, &data[pos], slen);
         if (0 != proc (proc_cls,
                        "dvi",
                        tmap[i].type,
                        EXTRACTOR_METAFORMAT_C_STRING,
                        "text/plain",
                        value,
                        strlen (value) + 1))
           return 1;
       }
       pos += slen + 1;
       break;
     }
     pos++;
   }
   return 0;
 }
 
 
 /**
  * Read 32-bit unsigned integer in big-endian format from 'data'.
  *
  * @param data pointer to integer (possibly unaligned)
  * @return 32-bit integer in host byte order
  */
 static uint32_t
 getIntAt (const void *data)
 {
   uint32_t p;
 
   memcpy (&p, data, 4);          /* ensure alignment! */
   return ntohl (p);
 }
 
 
 /**
  * Read 16-bit unsigned integer in big-endian format from 'data'.
  *
  * @param data pointer to integer (possibly unaligned)
  * @return 16-bit integer in host byte order
  */
 static uint16_t
 getShortAt (const void *data)
 {
   uint16_t p;
 
   memcpy (&p, data, sizeof (uint16_t));          /* ensure alignment! */
   return ntohs (p);
 }
 
 
 /* ****************** full text extraction ********************** */
 
 /**
  * Maximum number of fonts we track.
  */
 #define DVI_MAX_FONTS 1024
 
 /**
  * Size of the font hash table (a power of two, larger than
  * #DVI_MAX_FONTS).
  */
 #define DVI_FONT_HASH 2048
 
 /**
  * Maximum depth of the push/pop stack.
  */
 #define DVI_MAX_STACK 1024
 
 /**
  * Maximum number of pages we extract text from.
  */
 #define DVI_MAX_PAGES 50000
 
 /**
  * Maximum number of lines we collect over the whole document.
  */
 #define DVI_MAX_LINES 500000
 
 /**
  * Maximum number of bytes in one line.
  */
 #define DVI_MAX_LINE_BYTES (64 * 1024)
 
 /**
  * Font size assumed for undefined fonts (10pt in TeX's scaled points).
  */
 #define DVI_DEFAULT_SIZE 655360
 
 /**
  * Markers in the encoding tables for glyphs that expand to several
  * characters.  Real code points are never below 0x20.
  */
 #define LIG_FF 1
 #define LIG_FI 2
 #define LIG_FL 3
 #define LIG_FFI 4
 #define LIG_FFL 5
 #define LIG_SS 6
 
 
 /**
  * Font encodings we know how to map to Unicode.
  */
 enum DviEncoding
 {
   /**
    * TeX text (OT1), e.g. cmr10.
    */
   ENC_OT1,
 
   /**
    * TeX typewriter text (OT1 variant), e.g. cmtt10.
    */
   ENC_OT1TT,
 
   /**
    * Cork encoding (T1), e.g. ecrm1000, sfrm1000, ec-lmr10.
    */
   ENC_T1,
 
   /**
    * ASCII plus ISO-8859-1 upper half (roughly TeXBase1, 8r).
    */
   ENC_LATIN1,
 
   /**
    * TeX math italic, e.g. cmmi10.
    */
   ENC_MATHIT,
 
   /**
    * TeX math symbols, e.g. cmsy10.
    */
   ENC_SYMBOL,
 
   /**
    * Font whose glyphs we do not map (math extension, dingbats, ...).
    */
   ENC_NONE
 };
 
 
 /**
  * A font defined in the DVI file.
  */
 struct DviFont
 {
   /**
    * Font number used in the DVI file.
    */
   uint32_t k;
 
   /**
    * Scaled size in DVI units.
    */
   double size;
 
   /**
    * Encoding guessed from the font name.
    */
   enum DviEncoding enc;
 };
 
 
 /**
  * Registers of the DVI machine.
  */
 struct DviRegs
 {
   int64_t h;
   int64_t v;
   int64_t w;
   int64_t x;
   int64_t y;
   int64_t z;
 };
 
 
 /**
  * State of the full-text extraction.
  */
 struct DviText
 {
   /**
    * Extraction context, for keep-alives.
    */
   struct EXTRACTOR_ExtractContext *ec;
 
   /**
    * The DVI file.
    */
   const unsigned char *data;
 
   /**
    * Number of bytes in @e data.
    */
   size_t size;
 
   /**
    * Defined fonts.
    */
   struct DviFont fonts[DVI_MAX_FONTS];
 
   /**
    * Number of entries in @e fonts.
    */
   unsigned int num_fonts;
 
   /**
    * Hash table (open addressing) mapping font numbers to 1 + their
    * index in @e fonts; 0 marks an empty slot.
    */
   uint16_t font_hash[DVI_FONT_HASH];
 
   /**
    * Pages collected so far.
    */
   struct EXTRACTOR_FullTextPage *pages;
 
   /**
    * Geometry of the lines of each page.
    */
   struct EXTRACTOR_PageLineGeom **geoms;
 
   /**
    * Number of pages in @e pages / @e geoms.
    */
   unsigned int num_pages;
 
   /**
    * Allocated length of the geometry array of the current page.
    */
   unsigned int geom_cap;
 
   /**
    * Text of the current line.
    */
   char *lbuf;
 
   /**
    * Bytes in @e lbuf.
    */
   size_t llen;
 
   /**
    * Allocated size of @e lbuf.
    */
   size_t lcap;
 
   /**
    * 1 if a line is being collected.
    */
   int in_line;
 
   /**
    * 1 if a space must precede the next character of the line.
    */
   int pending_space;
 
   /**
    * Accent (combining code point) waiting for its base character, 0
    * for none.
    */
   uint32_t pending_accent;
 
   /**
    * 1 if @e pending_accent was placed over the preceding base character
    * (@e last_cp), so that it may belong to it rather than to the next.
    */
   int accent_post_ok;
 
   /**
    * Last base character appended to the line (for accents placed
    * after their base), 0 if none.
    */
   uint32_t last_cp;
 
   /**
    * Offset of @e last_cp in @e lbuf.
    */
   size_t last_cp_off;
 
   /**
    * Baseline of the current line.
    */
   int64_t line_v;
 
   /**
    * Left end of the current line.
    */
   double line_x0;
 
   /**
    * (Estimated) right end of the current line.
    */
   double line_x1;
 
   /**
    * Font size at the start of the current line.
    */
   double line_size;
 
   /**
    * (Estimated) horizontal position after the last glyph.
    */
   double last_end;
 
   /**
    * Total number of lines collected.
    */
   unsigned int total_lines;
 
   /**
    * Total number of text bytes collected.
    */
   size_t total_bytes;
 
   /**
    * Smallest and largest baseline seen.
    */
   int64_t vmin;
   int64_t vmax;
 
   /**
    * 1 if @e vmin and @e vmax are set.
    */
   int have_v;
 
   /**
    * Remaining number of opcodes we are willing to interpret.
    */
   uint64_t budget;
 
   /**
    * 1 if we ran out of memory or into a limit: stop collecting.
    */
   int full;
 };
 
 
 /**
  * Approximate widths (in 1/1000 em) of the glyphs of cmr10, used to
  * estimate where a glyph ends (DVI does not record glyph widths).
  */
 static const uint16_t cmr_widths[128] = {
   /* 0x00 Greek capitals */
   625, 833, 778, 694, 667, 750, 722, 778, 722, 778, 722,
   /* 0x0B ff fi fl ffi ffl */
   583, 556, 556, 833, 833,
   /* 0x10 dotless i/j, accents */
   278, 306, 500, 500, 500, 500, 500, 750, 444,
   /* 0x19 ss ae oe o/ AE OE O/ */
   500, 722, 778, 500, 903, 1014, 778,
   /* 0x20 */
   278, 278, 500, 833, 500, 833, 778, 278, 389, 389, 500, 778, 278, 333,
   278, 500,
   /* 0x30 digits */
   500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
   /* 0x3A */
   278, 278, 278, 778, 472, 472,
   /* 0x40 @ A-O */
   778, 750, 708, 722, 764, 681, 653, 785, 750, 361, 514, 778, 625, 917,
   750, 778,
   /* 0x50 P-Z [ " ] ^ . */
   681, 778, 736, 556, 722, 750, 750, 1028, 750, 750, 611, 278, 500, 278,
   500, 278,
   /* 0x60 ` a-o */
   278, 500, 556, 444, 556, 444, 306, 500, 556, 278, 306, 528, 278, 833,
   556, 500,
   /* 0x70 p-z -- --- accents */
   556, 528, 392, 394, 389, 556, 528, 722, 528, 528, 444, 500, 1000, 500,
   500, 500
 };
 
 
 /**
  * Greek capitals at 0x00-0x0A of OT1 and math italic fonts.
  */
 static const uint16_t greek_caps[11] = {
   0x0393, 0x0394, 0x0398, 0x039B, 0x039E, 0x03A0, 0x03A3, 0x03A5,
   0x03A6, 0x03A8, 0x03A9
 };
 
 /**
  * Glyphs 0x10-0x1F of OT1 fonts.
  */
 static const uint16_t ot1_10[16] = {
   0x0131, 0x0237, 0x0300, 0x0301, 0x030C, 0x0306, 0x0304, 0x030A,
   0x0327, 0x00DF, 0x00E6, 0x0153, 0x00F8, 0x00C6, 0x0152, 0x00D8
 };
 
 /**
  * Glyphs 0x00-0x1F of T1 fonts.
  */
 static const uint16_t t1_00[32] = {
   0x0300, 0x0301, 0x0302, 0x0303, 0x0308, 0x030B, 0x030A, 0x030C,
   0x0306, 0x0304, 0x0307, 0x0327, 0x0328, 0x201A, 0x2039, 0x203A,
   0x201C, 0x201D, 0x201E, 0x00AB, 0x00BB, 0x2013, 0x2014, 0,
   0, 0x0131, 0x0237, LIG_FF, LIG_FI, LIG_FL, LIG_FFI, LIG_FFL
 };
 
 /**
  * Glyphs 0x80-0xBF of T1 fonts.
  */
 static const uint16_t t1_80[64] = {
   0x0102, 0x0104, 0x0106, 0x010C, 0x010E, 0x011A, 0x0118, 0x011E,
   0x0139, 0x013D, 0x0141, 0x0143, 0x0147, 0x014A, 0x0150, 0x0154,
   0x0158, 0x015A, 0x0160, 0x015E, 0x0164, 0x0162, 0x0170, 0x016E,
   0x0178, 0x0179, 0x017D, 0x017B, 0x0132, 0x0130, 0x0111, 0x00A7,
   0x0103, 0x0105, 0x0107, 0x010D, 0x010F, 0x011B, 0x0119, 0x011F,
   0x013A, 0x013E, 0x0142, 0x0144, 0x0148, 0x014B, 0x0151, 0x0155,
   0x0159, 0x015B, 0x0161, 0x015F, 0x0165, 0x0163, 0x0171, 0x016F,
   0x00FF, 0x017A, 0x017E, 0x017C, 0x0133, 0x00A1, 0x00BF, 0x00A3
 };
 
 /**
  * Glyphs 0x0B-0x27 of math italic fonts (lower-case Greek).
  */
 static const uint16_t mathit_0b[29] = {
   0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03F5, 0x03B6, 0x03B7, 0x03B8,
   0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03C0, 0x03C1,
   0x03C3, 0x03C4, 0x03C5, 0x03D5, 0x03C7, 0x03C8, 0x03C9, 0x03B5,
   0x03D1, 0x03D6, 0x03F1, 0x03C2, 0x03C6
 };
 
 /**
  * Glyphs 0x00-0x7F of math symbol fonts (0: not mapped).
  */
 static const uint16_t symbol_map[128] = {
   0x2212, 0x22C5, 0x00D7, 0x2217, 0x00F7, 0x22C4, 0x00B1, 0x2213,
   0x2295, 0x2296, 0x2297, 0x2298, 0x2299, 0x25EF, 0x2218, 0x2022,
   0x224D, 0x2261, 0x2286, 0x2287, 0x2264, 0x2265, 0x2AAF, 0x2AB0,
   0x223C, 0x2248, 0x2282, 0x2283, 0x226A, 0x226B, 0x227A, 0x227B,
   0x2190, 0x2192, 0x2191, 0x2193, 0x2194, 0x2197, 0x2198, 0x2243,
   0x21D0, 0x21D2, 0x21D1, 0x21D3, 0x21D4, 0x2196, 0x2199, 0x221D,
   0x2032, 0x221E, 0x2208, 0x220B, 0x25B3, 0x25BD, 0, 0,
   0x2200, 0x2203, 0x00AC, 0x2205, 0x211C, 0x2111, 0x22A4, 0x22A5,
   0x2135, 'A', 'B', 'C', 'D', 'E', 'F', 'G',
   'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
   'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
   'X', 'Y', 'Z', 0x222A, 0x2229, 0x228E, 0x2227, 0x2228,
   0x22A2, 0x22A3, 0x230A, 0x230B, 0x2308, 0x2309, '{', '}',
   0x27E8, 0x27E9, '|', 0x2016, 0x2195, 0x21D5, '\\', 0x2240,
   0x221A, 0x2A3F, 0x2207, 0x222B, 0x2294, 0x2293, 0x2291, 0x2292,
   0x00A7, 0x2020, 0x2021, 0x00B6, 0x2663, 0x2662, 0x2661, 0x2660
 };
 
 
 /**
  * Map glyph @a c of a font with encoding @a enc to Unicode.
  *
  * @param enc font encoding
  * @param c glyph code
  * @return code point, a LIG_* marker, or 0 if the glyph has no text
  */
 static uint32_t
 dvi_map_glyph (enum DviEncoding enc,
                uint32_t c)
 {
   if (c > 255)
     return 0;
   switch (enc)
   {
   case ENC_OT1:
   case ENC_OT1TT:
     if (c >= 128)
       return 0;
     if (c < 0x0B)
       return greek_caps[c];
     if (ENC_OT1TT == enc)
     {
       switch (c)
       {
       case 0x0B: return 0x2191;
       case 0x0C: return 0x2193;
       case 0x0D: return '\'';
       case 0x0E: return 0x00A1;
       case 0x0F: return 0x00BF;
       case 0x7F: return 0x0308;
       default:
         break;
       }
       if (c >= 0x20)
         return c;
     }
     if (c < 0x10)
       return LIG_FF + (c - 0x0B);
     if (c < 0x20)
       return ot1_10[c - 0x10];
     switch (c)
     {
     case 0x20: return 0x0337; /* stroke of \l and \L */
     case 0x22: return 0x201D;
     case 0x27: return 0x2019;
     case 0x3C: return 0x00A1;
     case 0x3E: return 0x00BF;
     case 0x5C: return 0x201C;
     case 0x5E: return 0x0302;
     case 0x5F: return 0x0307;
     case 0x60: return 0x2018;
     case 0x7B: return 0x2013;
     case 0x7C: return 0x2014;
     case 0x7D: return 0x030B;
     case 0x7E: return 0x0303;
     case 0x7F: return 0x0308;
     default:
       return c;
     }
   case ENC_T1:
     if (c < 0x20)
       return t1_00[c];
     if (c == 0x7F)
       return '-';
     if (c < 0x80)
       return c;
     if (c < 0xC0)
       return t1_80[c - 0x80];
     switch (c)
     {
     case 0xD7: return 0x0152;
     case 0xDF: return LIG_SS;
     case 0xF7: return 0x0153;
     case 0xFF: return 0x00DF;
     default:
       return c;
     }
   case ENC_LATIN1:
     if ( ( (c >= 0x20) && (c < 0x7F) ) ||
          (c >= 0xA0) )
       return c;
     return 0;
   case ENC_MATHIT:
     if (c < 0x0B)
       return greek_caps[c];
     if (c < 0x28)
       return mathit_0b[c - 0x0B];
     if ( (c >= 0x30) && (c <= 0x3E) && (c != 0x3D) )
       return c;
     if (0x3D == c)
       return '/';
     if (0x40 == c)
       return 0x2202;
     if ( ( (c >= 'A') && (c <= 'Z') ) ||
          ( (c >= 'a') && (c <= 'z') ) )
       return c;
     if (0x60 == c)
       return 0x2113;
     if (0x7B == c)
       return 0x0131;
     if (0x7C == c)
       return 0x0237;
     return 0;
   case ENC_SYMBOL:
     if (c >= 128)
       return 0;
     return symbol_map[c];
   case ENC_NONE:
   default:
     return 0;
   }
 }
 
 
 /**
  * Estimate the width of glyph @a c, in 1/1000 em.
  *
  * @param enc font encoding
  * @param c glyph code
  * @return estimated width
  */
 static unsigned int
 dvi_glyph_width (enum DviEncoding enc,
                  uint32_t c)
 {
   switch (enc)
   {
   case ENC_OT1:
     return (c < 128) ? cmr_widths[c] : 500;
   case ENC_OT1TT:
     return 525;
   case ENC_T1:
   case ENC_LATIN1:
     if ( (c >= 0x21) && (c < 0x7F) &&
          (c != '"') && (c != '<') && (c != '>') && (c != '\\') &&
          (c != '_') && (c < '{') )
       return cmr_widths[c];
     if (c >= 0x80)
       return ( (c & 0x3F) < 0x20) ? 720 : 500;
     return 500;
   default:
     return 600;
   }
 }
 
 
 /**
  * Guess the encoding of a font from its name.
  *
  * @param name font name (not 0-terminated)
  * @param len length of @a name
  * @return guessed encoding
  */
 static enum DviEncoding
 dvi_font_encoding (const char *name,
                    size_t len)
 {
   static const char *const none[] = {
     "cmex", "lmex", "msam", "msbm", "lasy", "wasy", "line", "lcircle",
     "tc", "ts1-", "eufm", "eusm", "eurm", "rsfs", "stmary", "bbm", "dsrom",
     "pzd", "psy", "wncy", "manfnt", "logo", "esint", "cmbsy10x",
     NULL
   };
   static const char *const tt[] = {
     "cmtt", "cmsltt", "cmitt", "cmtcsc", "lmtt", "rm-lmtt", NULL
   };
   static const char *const sf[] = {
     "rm", "ti", "bx", "sl", "ss", "tt", "cc", "bi", "bl", "si", "sx",
     "so", "sq", "xc", "tl", "st", "oc", "ci", "ui", "vi", "bo",
     NULL
   };
   char lc[64];
   size_t i;
   size_t end;
 
   if (len >= sizeof (lc))
     len = sizeof (lc) - 1;
   for (i = 0; i < len; i++)
     lc[i] = (char) tolower ((unsigned char) name[i]);
   lc[len] = '\0';
   for (i = 0; NULL != none[i]; i++)
     if (0 == strncmp (lc, none[i], strlen (none[i])))
       return ENC_NONE;
   if ( (0 == strncmp (lc, "cmmi", 4)) ||
        (0 == strncmp (lc, "lmmi", 4)) ||
        (0 == strncmp (lc, "rm-lmmi", 7)) )
     return ENC_MATHIT;
   if ( (0 == strncmp (lc, "cmsy", 4)) ||
        (0 == strncmp (lc, "cmbsy", 5)) ||
        (0 == strncmp (lc, "lmsy", 4)) ||
        (0 == strncmp (lc, "lmbsy", 5)) )
     return ENC_SYMBOL;
   for (i = 0; NULL != tt[i]; i++)
     if (0 == strncmp (lc, tt[i], strlen (tt[i])))
       return ENC_OT1TT;
   if ( (0 == strncmp (lc, "ec-", 3)) ||
        (0 == strncmp (lc, "t1-", 3)) ||
        (0 == strncmp (lc, "cs-", 3)) ||
        (0 == strncmp (lc, "qx-", 3)) ||
        (0 == strncmp (lc, "l7x-", 4)) ||
        (0 == strncmp (lc, "t5-", 3)) ||
        (0 == strncmp (lc, "texnansi-", 9)) )
     return ENC_T1;
   if ( (len > 2) &&
        (0 == strncmp (lc, "ec", 2)) &&
        isalpha ((unsigned char) lc[2]) )
     return ENC_T1;
   if ( (len > 4) &&
        (0 == strncmp (lc, "sf", 2)) )
     for (i = 0; NULL != sf[i]; i++)
       if (0 == strncmp (&lc[2], sf[i], 2))
         return ENC_T1;
   /* Karl Berry's font names: <supplier><family><variant><encoding> */
   end = len;
   while ( (end > 0) &&
           isdigit ((unsigned char) lc[end - 1]) )
     end--;
   for (i = (end > 4) ? end - 4 : 0; i + 1 < end; i++)
   {
     if ('8' == lc[i])
     {
       if ('t' == lc[i + 1])
         return ENC_T1;
       if ('r' == lc[i + 1])
         return ENC_LATIN1;
       if ( ('c' == lc[i + 1]) ||
            ('y' == lc[i + 1]) )
         return ENC_NONE;
     }
   }
   return ENC_OT1;
 }
 
 
 /**
  * Check whether @a cp is a combining accent.
  *
  * @param cp code point
  * @return 1 if combining
  */
 static int
 is_accent (uint32_t cp)
 {
   return ( (cp >= 0x0300) && (cp < 0x0370) ) ? 1 : 0;
 }
 
 
 /**
  * Append raw bytes to the current line.
  *
  * @param t state
  * @param s bytes to append
  * @param len number of bytes
  */
 static void
 line_bytes (struct DviText *t,
             const char *s,
             size_t len)
 {
   if (t->llen + len > DVI_MAX_LINE_BYTES)
     return;
   if (t->llen + len > t->lcap)
   {
     size_t ncap = (0 == t->lcap) ? 256 : t->lcap;
     char *n;
 
     while (ncap < t->llen + len)
       ncap *= 2;
     n = realloc (t->lbuf,
                  ncap);
     if (NULL == n)
     {
       t->full = 1;
       return;
     }
     t->lbuf = n;
     t->lcap = ncap;
   }
   memcpy (&t->lbuf[t->llen],
           s,
           len);
   t->llen += len;
 }
 
 
 /**
  * Append a code point to the current line, preceded by a space if one
  * is pending.
  *
  * @param t state
  * @param cp code point (not a LIG_* marker)
  */
 static void
 line_cp (struct DviText *t,
          uint32_t cp)
 {
   char enc[4];
   size_t n;
 
   if ( (t->pending_space) &&
        (t->llen > 0) )
     line_bytes (t, " ", 1);
   t->pending_space = 0;
   if (cp < 0x80)
   {
     enc[0] = (char) cp;
     n = 1;
   }
   else if (cp < 0x800)
   {
     enc[0] = (char) (0xC0 | (cp >> 6));
     enc[1] = (char) (0x80 | (cp & 0x3F));
     n = 2;
   }
   else
   {
     enc[0] = (char) (0xE0 | (cp >> 12));
     enc[1] = (char) (0x80 | ((cp >> 6) & 0x3F));
     enc[2] = (char) (0x80 | (cp & 0x3F));
     n = 3;
   }
   line_bytes (t, enc, n);
 }
 
 
 static void
 resolve_accent (struct DviText *t);
 
 
 /**
  * Finish the current line (if any) and add it to the current page.
  *
  * @param t state
  */
 static void
 flush_line (struct DviText *t)
 {
   struct EXTRACTOR_FullTextPage *page;
   struct EXTRACTOR_PageLineGeom *g;
 
   if (! t->in_line)
     return;
   resolve_accent (t);
   t->in_line = 0;
   t->pending_space = 0;
   t->last_cp = 0;
   if ( (0 == t->llen) ||
        (t->full) ||
        (0 == t->num_pages) )
   {
     t->llen = 0;
     return;
   }
   if ( (t->total_lines >= DVI_MAX_LINES) ||
        (t->total_bytes + t->llen >= EXTRACTOR_FULLTEXT_MAX) )
   {
     t->full = 1;
     t->llen = 0;
     return;
   }
   page = &t->pages[t->num_pages - 1];
   if (page->num_lines >= t->geom_cap)
   {
     unsigned int ncap = (0 == t->geom_cap) ? 32 : 2 * t->geom_cap;
 
     g = realloc (t->geoms[t->num_pages - 1],
                  ncap * sizeof (*g));
     if (NULL == g)
     {
       t->full = 1;
       t->llen = 0;
       return;
     }
     t->geoms[t->num_pages - 1] = g;
     t->geom_cap = ncap;
   }
   g = &t->geoms[t->num_pages - 1][page->num_lines];
   if (0 != EXTRACTOR_fulltext_page_add_ (page,
                                          t->lbuf,
                                          t->llen,
                                          -1.0,
                                          0))
   {
     t->full = 1;
     t->llen = 0;
     return;
   }
   g->x0 = t->line_x0;
   g->x1 = t->line_x1;
   g->y = (double) t->line_v;
   g->size = t->line_size;
   if ( (! t->have_v) ||
        (t->line_v < t->vmin) )
     t->vmin = t->line_v;
   if ( (! t->have_v) ||
        (t->line_v > t->vmax) )
     t->vmax = t->line_v;
   t->have_v = 1;
   t->total_lines++;
   t->total_bytes += t->llen;
   t->llen = 0;
 }
 
 
 /**
  * Attach a pending accent to the preceding base character if it was
  * placed over it; otherwise drop it.
  *
  * @param t state
  */
 static void
 resolve_accent (struct DviText *t)
 {
   uint32_t comp;
   int pending_space;
 
   if (0 == t->pending_accent)
     return;
   if ( (t->accent_post_ok) &&
        (0 != t->last_cp) &&
        (t->last_cp_off <= t->llen) )
   {
     comp = EXTRACTOR_pagelayout_compose_ (t->last_cp,
                                           t->pending_accent);
     pending_space = t->pending_space;
     t->pending_space = 0;
     if (0 != comp)
     {
       t->llen = t->last_cp_off;
       line_cp (t, comp);
     }
     else
     {
       line_cp (t, t->pending_accent);
     }
     t->pending_space = pending_space;
     t->last_cp = 0;
   }
   t->pending_accent = 0;
   t->accent_post_ok = 0;
 }
 
 
 /**
  * Typeset glyph @a c of @a font at (@a h, @a v).
  *
  * @param t state
  * @param font the font, NULL if undefined
  * @param c glyph code
  * @param h horizontal position
  * @param v vertical position
  * @return estimated width of the glyph
  */
 static double
 put_glyph (struct DviText *t,
            const struct DviFont *font,
            uint32_t c,
            int64_t h,
            int64_t v)
 {
   enum DviEncoding enc = (NULL == font) ? ENC_OT1 : font->enc;
   double size = (NULL == font) ? DVI_DEFAULT_SIZE : font->size;
   double width = size * dvi_glyph_width (enc, c) / 1000.0;
   double hd = (double) h;
   uint32_t cp;
   double gap;
 
   cp = dvi_map_glyph (enc, c);
   if (0 == cp)
     return width;
   if (t->in_line)
   {
     double big = (size > t->line_size) ? size : t->line_size;
     double dv = (double) v - (double) t->line_v;
 
     if (fabs (dv) > 0.7 * big)
       flush_line (t);
   }
   if (! t->in_line)
   {
     t->in_line = 1;
     t->line_v = v;
     t->line_x0 = hd;
     t->line_x1 = hd;
     t->line_size = size;
     t->last_end = hd;
     t->pending_space = 0;
     t->pending_accent = 0;
     t->accent_post_ok = 0;
     t->last_cp = 0;
   }
   gap = hd - t->last_end;
   if (gap > 0.17 * size)
     t->pending_space = 1;
   if (hd + width > t->line_x1)
     t->line_x1 = hd + width;
   t->last_end = hd + width;
   if (is_accent (cp))
   {
     resolve_accent (t);
     t->pending_accent = cp;
     /* the accent overlaps the preceding base character: it belongs to
        that one unless the next glyph is set under it, too */
     t->accent_post_ok = ( (0 != t->last_cp) &&
                           (gap < -0.1 * size) &&
                           (! t->pending_space) ) ? 1 : 0;
     return width;
   }
   if ( (0 != t->pending_accent) &&
        (gap >= 0) )
     resolve_accent (t);
   if (cp < 0x20)
   {
     static const char *const ligs[] = {
       "", "ff", "fi", "fl", "ffi", "ffl", "SS"
     };
     const char *l = ligs[cp];
 
     t->pending_accent = 0;
     t->accent_post_ok = 0;
     while ('\0' != *l)
     {
       line_cp (t, (unsigned char) *l);
       l++;
     }
     t->last_cp = 0;
     return width;
   }
   if (0 != t->pending_accent)
   {
     uint32_t comp = EXTRACTOR_pagelayout_compose_ (cp,
                                                    t->pending_accent);
 
     if (0 != comp)
     {
       line_cp (t, comp);
     }
     else
     {
       line_cp (t, cp);
       line_cp (t, t->pending_accent);
     }
     t->pending_accent = 0;
     t->accent_post_ok = 0;
     t->last_cp = 0;
     return width;
   }
   {
     size_t before = t->llen;
 
     line_cp (t, cp);
     if (t->llen > before)
     {
       t->last_cp_off = t->llen - ( (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : 3);
       t->last_cp = cp;
     }
     else
     {
       t->last_cp = 0;
     }
   }
   return width;
 }
 
 
 /**
  * Read an unsigned big-endian integer of @a n bytes.
  *
  * @param t state
  * @param pos position to read at, updated
  * @param n number of bytes (1-4)
  * @param[out] ret value read
  * @return 0 on success, -1 if out of bounds
  */
 static int
 read_u (const struct DviText *t,
         size_t *pos,
         unsigned int n,
         uint32_t *ret)
 {
   uint32_t r = 0;
   unsigned int i;
 
   if ( (*pos > t->size) ||
        (t->size - *pos < n) )
     return -1;
   for (i = 0; i < n; i++)
     r = (r << 8) | t->data[*pos + i];
   *pos += n;
   *ret = r;
   return 0;
 }
 
 
 /**
  * Read a signed big-endian integer of @a n bytes.
  *
  * @param t state
  * @param pos position to read at, updated
  * @param n number of bytes (1-4)
  * @param[out] ret value read
  * @return 0 on success, -1 if out of bounds
  */
 static int
 read_s (const struct DviText *t,
         size_t *pos,
         unsigned int n,
         int64_t *ret)
 {
   uint32_t u;
 
   if (0 != read_u (t, pos, n, &u))
     return -1;
   if ( (n < 4) &&
        (u & (1U << (8 * n - 1))) )
     *ret = (int64_t) u - ((int64_t) 1 << (8 * n));
   else if (4 == n)
     *ret = (int64_t) (int32_t) u;
   else
     *ret = (int64_t) u;
   return 0;
 }
 
 
 /**
  * Hash a font number.
  *
  * @param k font number
  * @return initial slot in the font hash table
  */
 static unsigned int
 font_slot (uint32_t k)
 {
   return (unsigned int) ((k * 2654435761U) >> 21) & (DVI_FONT_HASH - 1);
 }
 
 
 /**
  * Look up font @a k.
  *
  * @param t state
  * @param k font number
  * @return the font, NULL if undefined
  */
 static const struct DviFont *
 find_font (const struct DviText *t,
            uint32_t k)
 {
   unsigned int h = font_slot (k);
 
   while (0 != t->font_hash[h])
   {
     const struct DviFont *f = &t->fonts[t->font_hash[h] - 1];
 
     if (f->k == k)
       return f;
     h = (h + 1) & (DVI_FONT_HASH - 1);
   }
   return NULL;
 }
 
 
 /**
  * Parse a fnt_def command (opcode already consumed) and register the
  * font.
  *
  * @param t state
  * @param pos position after the opcode, updated
  * @param n number of bytes of the font number (1-4)
  * @return 0 on success, -1 on malformed input
  */
 static int
 parse_fnt_def (struct DviText *t,
                size_t *pos,
                unsigned int n)
 {
   uint32_t k;
   uint32_t csum;
   int64_t s;
   uint32_t d;
   uint32_t a;
   uint32_t l;
   unsigned int i;
 
   if ( (0 != read_u (t, pos, n, &k)) ||
        (0 != read_u (t, pos, 4, &csum)) ||
        (0 != read_s (t, pos, 4, &s)) ||
        (0 != read_u (t, pos, 4, &d)) ||
        (0 != read_u (t, pos, 1, &a)) ||
        (0 != read_u (t, pos, 1, &l)) )
     return -1;
   if (t->size - *pos < a + l)
     return -1;
   if ( (NULL == find_font (t, k)) &&
        (t->num_fonts < DVI_MAX_FONTS) )
   {
     unsigned int h = font_slot (k);
 
     while (0 != t->font_hash[h])
       h = (h + 1) & (DVI_FONT_HASH - 1);
     t->font_hash[h] = (uint16_t) (t->num_fonts + 1);
     struct DviFont *f = &t->fonts[t->num_fonts++];
 
     f->k = k;
     if (s < 0)
       s = -s;
     if ( (0 == s) ||
          (s > (1 << 30)) )
       s = DVI_DEFAULT_SIZE;
     f->size = (double) s;
     f->enc = dvi_font_encoding ((const char *) &t->data[*pos + a],
                                 l);
   }
   *pos += a + l;
   (void) csum;
   (void) d;
   return 0;
 }
 
 
 /**
  * Interpret the page starting with the bop at @a bop and collect its
  * text into a new page.
  *
  * @param t state
  * @param bop offset of the page's bop command
  */
 static void
 interpret_page (struct DviText *t,
                 size_t bop)
 {
   struct DviRegs r;
   struct DviRegs *stack;
   unsigned int depth;
   const struct DviFont *font;
   size_t pos;
   struct EXTRACTOR_FullTextPage *np;
   struct EXTRACTOR_PageLineGeom **ng;
 
   np = realloc (t->pages,
                 (t->num_pages + 1) * sizeof (*np));
   if (NULL == np)
   {
     t->full = 1;
     return;
   }
   t->pages = np;
   ng = realloc (t->geoms,
                 (t->num_pages + 1) * sizeof (*ng));
   if (NULL == ng)
   {
     t->full = 1;
     return;
   }
   t->geoms = ng;
   memset (&t->pages[t->num_pages], 0, sizeof (*np));
   t->geoms[t->num_pages] = NULL;
   t->num_pages++;
   t->geom_cap = 0;
   stack = malloc (DVI_MAX_STACK * sizeof (*stack));
   if (NULL == stack)
   {
     t->full = 1;
     return;
   }
   memset (&r, 0, sizeof (r));
   depth = 0;
   font = NULL;
   pos = bop + 45;
   while ( (pos < t->size) &&
           (! t->full) )
   {
     unsigned char op = t->data[pos++];
     uint32_t u;
     int64_t s;
     int64_t s2;
 
     if (0 == t->budget)
     {
       t->full = 1;
       break;
     }
     t->budget--;
     if (0 == (t->budget & 0xFFFF))
       (void) t->ec->seek (t->ec->cls,
                           0,
                           SEEK_CUR); /* keep the host from giving up */
     if (op < 128)
     {
       r.h += (int64_t) put_glyph (t, font, op, r.h, r.v);
       continue;
     }
     if ( (op >= 171) &&
          (op <= 234) )
     {
       font = find_font (t, op - 171);
       continue;
     }
     switch (op)
     {
     case 128: case 129: case 130: case 131: /* set1..4 */
       if (0 != read_u (t, &pos, op - 127, &u))
         goto DONE;
       r.h += (int64_t) put_glyph (t, font, u, r.h, r.v);
       break;
     case 133: case 134: case 135: case 136: /* put1..4 */
       if (0 != read_u (t, &pos, op - 132, &u))
         goto DONE;
       (void) put_glyph (t, font, u, r.h, r.v);
       break;
     case 132: /* set_rule */
       if ( (0 != read_s (t, &pos, 4, &s)) ||
            (0 != read_s (t, &pos, 4, &s2)) )
         goto DONE;
       r.h += s2;
       break;
     case 137: /* put_rule */
       if ( (0 != read_s (t, &pos, 4, &s)) ||
            (0 != read_s (t, &pos, 4, &s2)) )
         goto DONE;
       break;
     case 138: /* nop */
       break;
     case 141: /* push */
       if (depth >= DVI_MAX_STACK)
         goto DONE;
       stack[depth++] = r;
       break;
     case 142: /* pop */
       if (0 == depth)
         goto DONE;
       r = stack[--depth];
       break;
     case 143: case 144: case 145: case 146: /* right1..4 */
       if (0 != read_s (t, &pos, op - 142, &s))
         goto DONE;
       r.h += s;
       break;
     case 147: /* w0 */
       r.h += r.w;
       break;
     case 148: case 149: case 150: case 151: /* w1..4 */
       if (0 != read_s (t, &pos, op - 147, &s))
         goto DONE;
       r.w = s;
       r.h += s;
       break;
     case 152: /* x0 */
       r.h += r.x;
       break;
     case 153: case 154: case 155: case 156: /* x1..4 */
       if (0 != read_s (t, &pos, op - 152, &s))
         goto DONE;
       r.x = s;
       r.h += s;
       break;
     case 157: case 158: case 159: case 160: /* down1..4 */
       if (0 != read_s (t, &pos, op - 156, &s))
         goto DONE;
       r.v += s;
       break;
     case 161: /* y0 */
       r.v += r.y;
       break;
     case 162: case 163: case 164: case 165: /* y1..4 */
       if (0 != read_s (t, &pos, op - 161, &s))
         goto DONE;
       r.y = s;
       r.v += s;
       break;
     case 166: /* z0 */
       r.v += r.z;
       break;
     case 167: case 168: case 169: case 170: /* z1..4 */
       if (0 != read_s (t, &pos, op - 166, &s))
         goto DONE;
       r.z = s;
       r.v += s;
       break;
     case 235: case 236: case 237: case 238: /* fnt1..4 */
       if (0 != read_u (t, &pos, op - 234, &u))
         goto DONE;
       font = find_font (t, u);
       break;
     case 239: case 240: case 241: case 242: /* xxx1..4 */
       if (0 != read_u (t, &pos, op - 238, &u))
         goto DONE;
       if (t->size - pos < u)
         goto DONE;
       pos += u;
       break;
     case 243: case 244: case 245: case 246: /* fnt_def1..4 */
       if (0 != parse_fnt_def (t, &pos, op - 242))
         goto DONE;
       break;
     case 140: /* eop */
     default: /* bop, pre, post, post_post, undefined */
       goto DONE;
     }
     /* keep the registers far away from overflowing */
     if ( (r.h > INT64_C (1) << 50) || (r.h < -(INT64_C (1) << 50)) ||
          (r.v > INT64_C (1) << 50) || (r.v < -(INT64_C (1) << 50)) )
       goto DONE;
   }
 DONE:
   flush_line (t);
   free (stack);
 }
 
 
 /**
  * Extract the full text of the DVI file and emit it.
  *
  * @param ec extraction context
  * @param data the DVI file
  * @param size number of bytes in @a data
  * @param post offset of the postamble
  * @param page_count number of pages
  * @return 0 to continue, 1 if the callback asked us to stop
  */
 static int
 dvi_fulltext (struct EXTRACTOR_ExtractContext *ec,
               const unsigned char *data,
               size_t size,
               size_t post,
               unsigned int page_count)
 {
   struct DviText *t;
   size_t *bops;
   size_t pos;
   unsigned int n;
   unsigned int i;
   int64_t l = 0;
   double top;
   double bottom;
   int ret = 0;
 
   if ( (0 == page_count) ||
        (post > size) ||
        (size - post < 29) )
     return 0;
   t = calloc (1, sizeof (*t));
   if (NULL == t)
     return 0;
   t->ec = ec;
   t->data = data;
   t->size = size;
   t->budget = 4 * (uint64_t) size + 1000000;
   /* fonts from the postamble */
   pos = post + 29;
   while (pos < size)
   {
     unsigned char op = data[pos++];
 
     if (138 == op)
       continue;
     if ( (op < 243) ||
          (op > 246) ||
          (0 != parse_fnt_def (t, &pos, op - 242)) )
       break;
   }
   pos = post + 17;
   (void) read_s (t, &pos, 4, &l);
   /* list of pages, in order */
   if (page_count > DVI_MAX_PAGES)
     page_count = DVI_MAX_PAGES;
   bops = malloc (page_count * sizeof (size_t));
   if (NULL == bops)
   {
     free (t);
     return 0;
   }
   {
     uint32_t p;
     uint32_t prev;
     unsigned int total;
 
     total = 0;
     p = getIntAt (&data[post + 1]);
     prev = UINT32_MAX;
     while ( (UINT32_MAX != p) &&
             ((size_t) p + 45 <= size) &&
             (p < prev) &&
             (139 == data[p]) )
     {
       total++;
       prev = p;
       p = getIntAt (&data[p + 41]);
     }
     n = (total < page_count) ? total : page_count;
     p = getIntAt (&data[post + 1]);
     prev = UINT32_MAX;
     while ( (total > 0) &&
             (UINT32_MAX != p) &&
             ((size_t) p + 45 <= size) &&
             (p < prev) &&
             (139 == data[p]) )
     {
       total--;
       if (total < n)
         bops[total] = p;
       prev = p;
       p = getIntAt (&data[p + 41]);
     }
   }
   for (i = 0; (i < n) && (! t->full); i++)
     interpret_page (t, bops[i]);
   free (bops);
   /* relative vertical positions */
   top = 0;
   bottom = (l > 0) ? (double) l : 0;
   if (t->have_v)
   {
     if ((double) t->vmin < top)
       top = (double) t->vmin;
     if ((double) t->vmax > bottom)
       bottom = (double) t->vmax;
   }
   for (i = 0; i < t->num_pages; i++)
   {
     unsigned int j;
 
     for (j = 0; j < t->pages[i].num_lines; j++)
     {
       double y = -1;
 
       if (bottom > top)
         y = (t->geoms[i][j].y - top) / (bottom - top);
       if (y > 1)
         y = 1;
       t->pages[i].lines[j].y = y;
     }
   }
   if (t->num_pages > 0)
   {
     struct EXTRACTOR_FullText ft;
 
     EXTRACTOR_fulltext_filter_margins_ (t->pages,
                                         t->num_pages);
     EXTRACTOR_pagelayout_paragraphs_ (t->pages,
                                       t->geoms,
                                       t->num_pages,
                                       0.06);
     EXTRACTOR_fulltext_init_ (&ft);
     EXTRACTOR_fulltext_append_pages_ (&ft,
                                       t->pages,
                                       t->num_pages);
     ret = EXTRACTOR_fulltext_emit_ (&ft,
                                     ec,
                                     "dvi");
     EXTRACTOR_fulltext_clear_ (&ft);
   }
   for (i = 0; i < t->num_pages; i++)
   {
     EXTRACTOR_fulltext_page_clear_ (&t->pages[i]);
     free (t->geoms[i]);
   }
   free (t->pages);
   free (t->geoms);
   free (t->lbuf);
   free (t);
   return (0 != ret) ? 1 : 0;
 }
 
 
 /**
  * Main entry method for the 'application/x-dvi' extraction plugin.
  *
  * @param ec extraction context provided to the plugin
  */
 void
 EXTRACTOR_dvi_extract_method (struct EXTRACTOR_ExtractContext *ec);
 
 void
 EXTRACTOR_dvi_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   unsigned int klen;
   uint32_t pos;
   uint32_t opos;
   unsigned int len;
   unsigned int pageCount;
   char pages[16];
   void *buf;
   unsigned char *data;
   uint64_t size;
   uint64_t off;
   ssize_t iret;
   uint32_t post;
 
   if (40 >= (iret = ec->read (ec->cls, &buf, 1024)))
     return;
   data = buf;
   if ( (data[0] != 247) ||
        (data[1] != 2) )
     return;                /* cannot be DVI or unsupported version */
   klen = data[14];
   size = ec->get_size (ec->cls);
   if (size > 16 * 1024 * 1024)
     return; /* too large */
   if (klen + 15 > size)
     return; /* malformed klen */
   if (NULL == (data = malloc ((size_t) size)))
     return; /* out of memory */
   memcpy (data, buf, iret);
   off = iret;
   while (off < size)
   {
     if (0 >= (iret = ec->read (ec->cls, &buf, 16 * 1024)))
     {
       free (data);
       return;
     }
     memcpy (&data[off], buf, iret);
     off += iret;
   }
   pos = size - 1;
   while ( (223 == data[pos]) &&
           (pos > 0) )
     pos--;
   if ( (2 != data[pos]) ||
        (pos < 40) )
     goto CLEANUP;
   pos--;
   pos -= 4;
   /* assert pos at 'post_post tag' */
   if (data[pos] != 249)
     goto CLEANUP;
   opos = pos;
   pos = getIntAt (&data[opos + 1]);
   if ( (pos + 25 > size) ||
        (pos + 25 < pos) )
     goto CLEANUP;
   /* assert pos at 'post' command */
   if (data[pos] != 248)
     goto CLEANUP;
   post = pos;
   pageCount = 0;
   opos = pos;
   pos = getIntAt (&data[opos + 1]);
   while (1)
   {
     if (UINT32_MAX == pos)
       break;
     if ( (pos + 45 > size) ||
          (pos + 45 < pos) )
       goto CLEANUP;
     if (data[pos] != 139)       /* expect 'bop' */
       goto CLEANUP;
     pageCount++;
     opos = pos;
     pos = getIntAt (&data[opos + 41]);
     if (UINT32_MAX == pos)
       break;
     if (pos >= opos)
       goto CLEANUP;       /* invalid! */
   }
   /* ok, now we believe it's a dvi... */
   snprintf (pages,
             sizeof (pages),
             "%u",
             pageCount);
   if (0 != ec->proc (ec->cls,
                      "dvi",
                      EXTRACTOR_METATYPE_PAGE_COUNT,
                      EXTRACTOR_METAFORMAT_UTF8,
                      "text/plain",
                      pages,
                      strlen (pages) + 1))
     goto CLEANUP;
   if (0 != ec->proc (ec->cls,
                      "dvi",
                      EXTRACTOR_METATYPE_MIMETYPE,
                      EXTRACTOR_METAFORMAT_UTF8,
                      "text/plain",
                      "application/x-dvi",
                      strlen ("application/x-dvi") + 1))
     goto CLEANUP;
   {
     char comment[klen + 1];
 
     comment[klen] = '\0';
     memcpy (comment, &data[15], klen);
     if (0 != ec->proc (ec->cls,
                        "dvi",
                        EXTRACTOR_METATYPE_COMMENT,
                        EXTRACTOR_METAFORMAT_C_STRING,
                        "text/plain",
                        comment,
                        strlen (comment) + 1))
       goto CLEANUP;
   }
   /* try to find PDF/ps special */
   pos = opos;
   while ( (size >= 100) &&
           (pos < size - 100) )
   {
     switch (data[pos])
     {
     case 139:                  /* begin page 'bop', we typically have to skip that one to
                                    find the zzz's */
       pos += 45;                /* skip bop */
       break;
     case 239:                  /* zzz1 */
       len = data[pos + 1];
       if ( (pos + 2 + len < size) &&
            (0 != parseZZZ ((const char *) data, pos + 2, len, ec->proc,
                            ec->cls)) )
         goto CLEANUP;
       pos += len + 2;
       break;
     case 240:                  /* zzz2 */
       len = getShortAt (&data[pos + 1]);
       if ( (pos + 3 + len < size) &&
            (0 != parseZZZ ((const char *) data, pos + 3, len, ec->proc,
                            ec->cls)) )
         goto CLEANUP;
       pos += len + 3;
       break;
     case 241:                  /* zzz3, who uses that? */
       len = (getShortAt (&data[pos + 1])) + 65536 * data[pos + 3];
       if ( (pos + 4 + len < size) &&
            (0 != parseZZZ ((const char *) data, pos + 4, len, ec->proc,
                            ec->cls)) )
         goto CLEANUP;
       pos += len + 4;
       break;
     case 242:                  /* zzz4, hurray! */
       len = getIntAt (&data[pos + 1]);
       if ( (pos + 5 + len < size) &&
            (0 != parseZZZ ((const char *) data, pos + 5, len, ec->proc,
                            ec->cls)) )
         goto CLEANUP;
       pos += len + 5;
       break;
     default:                   /* unsupported opcode, abort scan */
       goto FULLTEXT;
     }
   }
 FULLTEXT:
   if (EXTRACTOR_fulltext_requested_ (ec->config))
     (void) dvi_fulltext (ec,
                          data,
                          (size_t) size,
                          post,
                          pageCount);
 CLEANUP:
   free (data);
 }
 
 
 /* end of dvi_extractor.c */