Ignore:
Timestamp:
Sep 7, 2012, 8:38:55 AM (9 years ago)
Author:
Silvan Scherrer
Message:

updated poppler to 0.20.3

Location:
trunk/poppler/mypoppler/fofi
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/fofi/FoFiBase.cc

    r497 r515  
    2929
    3030#include <stdio.h>
     31#include <limits.h>
    3132#include "goo/gmem.h"
    3233#include "poppler/Error.h"
     
    5556
    5657  if (!(f = fopen(fileName, "rb"))) {
    57     error(-1, "Cannot open '%s'", fileName);
     58    error(errIO, -1, "Cannot open '{0:s}'", fileName);
    5859    return NULL;
    5960  }
    6061  if (fseek(f, 0, SEEK_END) != 0) {
    61     error(-1, "Cannot seek to end of '%s'", fileName);
     62    error(errIO, -1, "Cannot seek to end of '{0:s}'", fileName);
    6263    fclose(f);
    6364    return NULL;
     
    6566  n = (int)ftell(f);
    6667  if (n < 0) {
    67     error(-1, "Cannot determine length of '%s'", fileName);
     68    error(errIO, -1, "Cannot determine length of '{0:s}'", fileName);
    6869    fclose(f);
    6970    return NULL;
    7071  }
    7172  if (fseek(f, 0, SEEK_SET) != 0) {
    72     error(-1, "Cannot seek to start of '%s'", fileName);
     73    error(errIO, -1, "Cannot seek to start of '{0:s}'", fileName);
    7374    fclose(f);
    7475    return NULL;
     
    110111  int x;
    111112
    112   if (pos < 0 || pos+1 >= len) {
     113  if (pos < 0 || pos+1 >= len || pos > INT_MAX - 1) {
    113114    *ok = gFalse;
    114115    return 0;
     
    125126  int x;
    126127
    127   if (pos < 0 || pos+1 >= len) {
     128  if (pos < 0 || pos+1 >= len || pos > INT_MAX - 1) {
    128129    *ok = gFalse;
    129130    return 0;
     
    137138  int x;
    138139
    139   if (pos < 0 || pos+3 >= len) {
     140  if (pos < 0 || pos+3 >= len || pos > INT_MAX - 3) {
    140141    *ok = gFalse;
    141142    return 0;
     
    154155  Guint x;
    155156
    156   if (pos < 0 || pos+3 >= len) {
     157  if (pos < 0 || pos+3 >= len || pos > INT_MAX - 3) {
    157158    *ok = gFalse;
    158159    return 0;
     
    162163  x = (x << 8) + file[pos+2];
    163164  x = (x << 8) + file[pos+3];
     165  return x;
     166}
     167
     168Guint FoFiBase::getU32LE(int pos, GBool *ok) {
     169  Guint x;
     170
     171  if (pos < 0 || pos+3 >= len || pos > INT_MAX - 3) {
     172    *ok = gFalse;
     173    return 0;
     174  }
     175  x = file[pos+3];
     176  x = (x << 8) + file[pos+2];
     177  x = (x << 8) + file[pos+1];
     178  x = (x << 8) + file[pos];
    164179  return x;
    165180}
     
    169184  int i;
    170185
    171   if (pos < 0 || pos + size > len) {
     186  if (pos < 0 || pos + size > len || pos > INT_MAX - size) {
    172187    *ok = gFalse;
    173188    return 0;
  • trunk/poppler/mypoppler/fofi/FoFiBase.h

    r2 r515  
    1818//------------------------------------------------------------------------
    1919
    20 typedef void (*FoFiOutputFunc)(void *stream, char *data, int len);
     20typedef void (*FoFiOutputFunc)(void *stream, const char *data, int len);
    2121
    2222//------------------------------------------------------------------------
     
    4343  int getS32BE(int pos, GBool *ok);
    4444  Guint getU32BE(int pos, GBool *ok);
     45  Guint getU32LE(int pos, GBool *ok);
    4546  Guint getUVarBE(int pos, int size, GBool *ok);
    4647
  • trunk/poppler/mypoppler/fofi/FoFiEncodings.cc

    r2 r515  
    2020//------------------------------------------------------------------------
    2121
    22 char *fofiType1StandardEncoding[256] = {
     22const char *fofiType1StandardEncoding[256] = {
    2323  NULL,
    2424  NULL,
     
    279279};
    280280
    281 char *fofiType1ExpertEncoding[256] = {
     281const char *fofiType1ExpertEncoding[256] = {
    282282  NULL,
    283283  NULL,
     
    542542//------------------------------------------------------------------------
    543543
    544 char *fofiType1CStdStrings[391] = {
     544const char *fofiType1CStdStrings[391] = {
    545545  ".notdef",
    546546  "space",
  • trunk/poppler/mypoppler/fofi/FoFiEncodings.h

    r2 r515  
    2020//------------------------------------------------------------------------
    2121
    22 extern char *fofiType1StandardEncoding[256];
    23 extern char *fofiType1ExpertEncoding[256];
     22extern const char *fofiType1StandardEncoding[256];
     23extern const char *fofiType1ExpertEncoding[256];
    2424
    2525//------------------------------------------------------------------------
     
    2727//------------------------------------------------------------------------
    2828
    29 extern char *fofiType1CStdStrings[391];
     29extern const char *fofiType1CStdStrings[391];
    3030extern Gushort fofiType1CISOAdobeCharset[229];
    3131extern Gushort fofiType1CExpertCharset[166];
  • trunk/poppler/mypoppler/fofi/FoFiTrueType.cc

    r277 r515  
    1717// Copyright (C) 2007 Koji Otani <sho@bbr.jp>
    1818// Copyright (C) 2007 Carlos Garcia Campos <carlosgc@gnome.org>
    19 // Copyright (C) 2008, 2009 Albert Astals Cid <aacid@kde.org>
     19// Copyright (C) 2008, 2009, 2012 Albert Astals Cid <aacid@kde.org>
    2020// Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com>
     21// Copyright (C) 2012 Suzuki Toshiya <mpsuzuki@hiroshima-u.ac.jp>
     22// Copyright (C) 2012 Adrian Johnson <ajohnson@redneon.com>
    2123//
    2224// To see a description of the changes please see the Changelog file that
     
    3335#include <stdlib.h>
    3436#include <string.h>
     37#include <algorithm>
    3538#include "goo/gtypes.h"
    3639#include "goo/gmem.h"
     
    138141#define vertTag 0x76657274
    139142
    140 static int cmpTrueTypeLocaOffset(const void *p1, const void *p2) {
    141   TrueTypeLoca *loca1 = (TrueTypeLoca *)p1;
    142   TrueTypeLoca *loca2 = (TrueTypeLoca *)p2;
    143 
    144   if (loca1->origOffset == loca2->origOffset) {
    145     return loca1->idx - loca2->idx;
    146   }
    147   return loca1->origOffset - loca2->origOffset;
    148 }
    149 
    150 static int cmpTrueTypeLocaIdx(const void *p1, const void *p2) {
    151   TrueTypeLoca *loca1 = (TrueTypeLoca *)p1;
    152   TrueTypeLoca *loca2 = (TrueTypeLoca *)p2;
    153 
    154   return loca1->idx - loca2->idx;
    155 }
    156 
    157 static int cmpTrueTypeTableTag(const void *p1, const void *p2) {
    158   TrueTypeTable *tab1 = (TrueTypeTable *)p1;
    159   TrueTypeTable *tab2 = (TrueTypeTable *)p2;
    160 
    161   return (int)tab1->tag - (int)tab2->tag;
    162 }
     143struct cmpTrueTypeLocaOffsetFunctor {
     144  bool operator()(const TrueTypeLoca &loca1, const TrueTypeLoca &loca2) {
     145    if (loca1.origOffset == loca2.origOffset) {
     146      return loca1.idx < loca2.idx;
     147    }
     148    return loca1.origOffset < loca2.origOffset;
     149  }
     150};
     151
     152struct cmpTrueTypeLocaIdxFunctor {
     153  bool operator()(const TrueTypeLoca &loca1, const TrueTypeLoca &loca2) {
     154    return loca1.idx < loca2.idx;
     155  }
     156};
     157
     158struct cmpTrueTypeTableTagFunctor {
     159  bool operator()(const TrueTypeTable &tab1, const TrueTypeTable &tab2) {
     160    return tab1.tag < tab2.tag;
     161  }
     162};
    163163
    164164//------------------------------------------------------------------------
    165165
    166166struct T42Table {
    167   char *tag;                    // 4-byte tag
     167  const char *tag;              // 4-byte tag
    168168  GBool required;               // required by the TrueType spec?
    169169};
     
    195195// Glyph names in some arbitrary standard order that Apple uses for
    196196// their TrueType fonts.
    197 static char *macGlyphNames[258] = {
     197static const char *macGlyphNames[258] = {
    198198  ".notdef",        "null",           "CR",             "space",
    199199  "exclam",         "quotedbl",       "numbersign",     "dollar",
     
    233233  "trademark",      "acute",          "dieresis",       "notequal",
    234234  "AE",             "Oslash",         "infinity",       "plusminus",
    235   "lessequal",      "greaterequal",   "yen",            "mu1",
     235  "lessequal",      "greaterequal",   "yen",            "mu",
    236236  "partialdiff",    "summation",      "product",        "pi",
    237   "integral",       "ordfeminine",    "ordmasculine",   "Ohm",
     237  "integral",       "ordfeminine",    "ordmasculine",   "Omega",
    238238  "ae",             "oslash",         "questiondown",   "exclamdown",
    239239  "logicalnot",     "radical",        "florin",         "approxequal",
     
    341341}
    342342
    343 Gushort FoFiTrueType::mapCodeToGID(int i, Guint c) {
    344   Gushort gid;
     343int FoFiTrueType::mapCodeToGID(int i, Guint c) {
     344  int gid;
    345345  Guint segCnt, segEnd, segStart, segDelta, segOffset;
    346346  Guint cmapFirst, cmapLen;
     
    445445}
    446446
    447 Gushort *FoFiTrueType::getCIDToGIDMap(int *nCIDs) {
    448   FoFiType1C *ff;
    449   Gushort *map;
     447GBool FoFiTrueType::getCFFBlock(char **start, int *length) {
    450448  int i;
    451449
    452   *nCIDs = 0;
    453450  if (!openTypeCFF) {
    454     return NULL;
     451    return gFalse;
    455452  }
    456453  i = seekTable("CFF ");
    457454  if (!checkRegion(tables[i].offset, tables[i].len)) {
     455    return gFalse;
     456  }
     457  *start = (char *)file + tables[i].offset;
     458  *length = tables[i].len;
     459  return gTrue;
     460}
     461
     462int *FoFiTrueType::getCIDToGIDMap(int *nCIDs) {
     463  char *start;
     464  int length;
     465  FoFiType1C *ff;
     466  int *map;
     467
     468  *nCIDs = 0;
     469  if (!getCFFBlock(&start, &length)) {
    458470    return NULL;
    459471  }
    460   if (!(ff = FoFiType1C::make((char *)file + tables[i].offset,
    461                               tables[i].len))) {
     472  if (!(ff = FoFiType1C::make(start, length))) {
    462473    return NULL;
    463474  }
     
    491502}
    492503
     504void FoFiTrueType::getFontMatrix(double *mat) {
     505  char *start;
     506  int length;
     507  FoFiType1C *ff;
     508
     509  if (!getCFFBlock(&start, &length)) {
     510    return;
     511  }
     512  if (!(ff = FoFiType1C::make(start, length))) {
     513    return;
     514  }
     515  ff->getFontMatrix(mat);
     516  delete ff;
     517}
     518
    493519void FoFiTrueType::convertToType42(char *psName, char **encoding,
    494                                    Gushort *codeToGID,
     520                                   int *codeToGID,
    495521                                   FoFiOutputFunc outputFunc,
    496522                                   void *outputStream) {
    497523  GooString *buf;
     524  int maxUsedGlyph;
    498525  GBool ok;
    499526
     
    525552  cvtEncoding(encoding, outputFunc, outputStream);
    526553  cvtCharStrings(encoding, codeToGID, outputFunc, outputStream);
    527   cvtSfnts(outputFunc, outputStream, NULL, gFalse);
     554  cvtSfnts(outputFunc, outputStream, NULL, gFalse, &maxUsedGlyph);
    528555
    529556  // end the dictionary and define the font
     
    531558}
    532559
    533 void FoFiTrueType::convertToType1(char *psName, char **newEncoding,
     560void FoFiTrueType::convertToType1(char *psName, const char **newEncoding,
    534561                                  GBool ascii, FoFiOutputFunc outputFunc,
    535562                                  void *outputStream) {
     563  char *start;
     564  int length;
    536565  FoFiType1C *ff;
    537   int i;
    538 
    539   if (!openTypeCFF) {
     566
     567  if (!getCFFBlock(&start, &length)) {
    540568    return;
    541569  }
    542   i = seekTable("CFF ");
    543   if (!checkRegion(tables[i].offset, tables[i].len)) {
    544     return;
    545   }
    546   if (!(ff = FoFiType1C::make((char *)file + tables[i].offset,
    547                               tables[i].len))) {
     570  if (!(ff = FoFiType1C::make(start, length))) {
    548571    return;
    549572  }
     
    553576
    554577void FoFiTrueType::convertToCIDType2(char *psName,
    555                                      Gushort *cidMap, int nCIDs,
     578                                     int *cidMap, int nCIDs,
    556579                                     GBool needVerticalMetrics,
    557580                                     FoFiOutputFunc outputFunc,
    558581                                     void *outputStream) {
    559582  GooString *buf;
    560   Gushort cid;
     583  int cid, maxUsedGlyph;
    561584  GBool ok;
    562585  int i, j, k;
     
    674697
    675698  // write the guts of the dictionary
    676   cvtSfnts(outputFunc, outputStream, NULL, needVerticalMetrics);
     699  cvtSfnts(outputFunc, outputStream, NULL, needVerticalMetrics, &maxUsedGlyph);
    677700
    678701  // end the dictionary and define the font
     
    682705}
    683706
    684 void FoFiTrueType::convertToCIDType0(char *psName,
     707void FoFiTrueType::convertToCIDType0(char *psName, int *cidMap, int nCIDs,
    685708                                     FoFiOutputFunc outputFunc,
    686709                                     void *outputStream) {
     710  char *start;
     711  int length;
    687712  FoFiType1C *ff;
    688   int i;
    689 
    690   if (!openTypeCFF) {
     713
     714  if (!getCFFBlock(&start, &length)) {
    691715    return;
    692716  }
    693   i = seekTable("CFF ");
    694   if (!checkRegion(tables[i].offset, tables[i].len)) {
     717  if (!(ff = FoFiType1C::make(start, length))) {
    695718    return;
    696719  }
    697   if (!(ff = FoFiType1C::make((char *)file + tables[i].offset,
    698                               tables[i].len))) {
    699     return;
    700   }
    701   ff->convertToCIDType0(psName, outputFunc, outputStream);
     720  ff->convertToCIDType0(psName, cidMap, nCIDs, outputFunc, outputStream);
    702721  delete ff;
    703722}
    704723
    705 void FoFiTrueType::convertToType0(char *psName, Gushort *cidMap, int nCIDs,
     724void FoFiTrueType::convertToType0(char *psName, int *cidMap, int nCIDs,
    706725                                  GBool needVerticalMetrics,
    707726                                  FoFiOutputFunc outputFunc,
     
    709728  GooString *buf;
    710729  GooString *sfntsName;
    711   int n, i, j;
     730  int maxUsedGlyph, n, i, j;
    712731
    713732  if (openTypeCFF) {
     
    717736  // write the Type 42 sfnts array
    718737  sfntsName = (new GooString(psName))->append("_sfnts");
    719   cvtSfnts(outputFunc, outputStream, sfntsName, needVerticalMetrics);
     738  cvtSfnts(outputFunc, outputStream, sfntsName, needVerticalMetrics,
     739           &maxUsedGlyph);
    720740  delete sfntsName;
    721741
    722742  // write the descendant Type 42 fonts
    723   n = cidMap ? nCIDs : nGlyphs;
     743  // (The following is a kludge: nGlyphs is the glyph count from the
     744  // maxp table; maxUsedGlyph is the max glyph number that has a
     745  // non-zero-length description, from the loca table.  The problem is
     746  // that some TrueType font subsets fail to change the glyph count,
     747  // i.e., nGlyphs is much larger than maxUsedGlyph+1, which results
     748  // in an unnecessarily huge Type 0 font.  But some other PDF files
     749  // have fonts with only zero or one used glyph, and a content stream
     750  // that refers to one of the unused glyphs -- this results in PS
     751  // errors if we simply use maxUsedGlyph+1 for the Type 0 font.  So
     752  // we compromise by always defining at least 256 glyphs.)
     753  if (cidMap) {
     754    n = nCIDs;
     755  } else if (nGlyphs > maxUsedGlyph + 256) {
     756    if (maxUsedGlyph <= 255) {
     757      n = 256;
     758    } else {
     759      n = maxUsedGlyph + 1;
     760    }
     761  } else {
     762    n = nGlyphs;
     763  }
    724764  for (i = 0; i < n; i += 256) {
    725765    (*outputFunc)(outputStream, "10 dict begin\n", 14);
     
    786826}
    787827
    788 void FoFiTrueType::convertToType0(char *psName,
     828void FoFiTrueType::convertToType0(char *psName, int *cidMap, int nCIDs,
    789829                                  FoFiOutputFunc outputFunc,
    790830                                  void *outputStream) {
     831  char *start;
     832  int length;
    791833  FoFiType1C *ff;
    792   int i;
    793 
    794   if (!openTypeCFF) {
     834
     835  if (!getCFFBlock(&start, &length)) {
    795836    return;
    796837  }
    797   i = seekTable("CFF ");
    798   if (!checkRegion(tables[i].offset, tables[i].len)) {
     838  if (!(ff = FoFiType1C::make(start, length))) {
    799839    return;
    800840  }
    801   if (!(ff = FoFiType1C::make((char *)file + tables[i].offset,
    802                               tables[i].len))) {
    803     return;
    804   }
    805   ff->convertToType0(psName, outputFunc, outputStream);
     841  ff->convertToType0(psName, cidMap, nCIDs, outputFunc, outputStream);
    806842  delete ff;
    807843}
     
    809845void FoFiTrueType::writeTTF(FoFiOutputFunc outputFunc,
    810846                            void *outputStream, char *name,
    811                             Gushort *codeToGID) {
    812   // this substitute cmap table maps char codes 0000-ffff directly to
    813   // glyphs 0000-ffff
    814   static char cmapTab[36] = {
     847                            int *codeToGID) {
     848  // this substitute cmap table maps char code ffff to glyph 0,
     849  // with tables for MacRoman and MS Unicode
     850  static char cmapTab[44] = {
    815851    0, 0,                       // table version number
    816     0, 1,                       // number of encoding tables
     852    0, 2,                       // number of encoding tables
    817853    0, 1,                       // platform ID
    818854    0, 0,                       // encoding ID
    819     0, 0, 0, 12,                // offset of subtable
     855    0, 0, 0, 20,                // offset of subtable
     856    0, 3,                       // platform ID
     857    0, 1,                       // encoding ID
     858    0, 0, 0, 20,                // offset of subtable
    820859    0, 4,                       // subtable format
    821860    0, 24,                      // subtable length
     
    827866    (char)0xff, (char)0xff,     // endCount[0]
    828867    0, 0,                       // reserved
    829     0, 0,                       // startCount[0]
    830     0, 0,                       // idDelta[0]
    831     0, 0                        // pad to a mulitple of four bytes
     868    (char)0xff, (char)0xff,     // startCount[0]
     869    0, 1,                       // idDelta[0]
     870    0, 0                        // idRangeOffset[0]
    832871  };
    833872  static char nameTab[8] = {
     
    851890    0, 1,                       // version
    852891    0, 1,                       // xAvgCharWidth
    853     0, 0,                       // usWeightClass
    854     0, 0,                       // usWidthClass
     892    0x01, (char)0x90,           // usWeightClass
     893    0, 5,                       // usWidthClass
    855894    0, 0,                       // fsType
    856895    0, 0,                       // ySubscriptXSize
     
    878917    0, 0,                       // sTypoDescender
    879918    0, 0,                       // sTypoLineGap
    880     0, 0,                       // usWinAscent
    881     0, 0,                       // usWinDescent
    882     0, 0, 0, 0,                 // ulCodePageRange1
     919    0x20, 0x00,                 // usWinAscent
     920    0x20, 0x00,                 // usWinDescent
     921    0, 0, 0, 1,                 // ulCodePageRange1
    883922    0, 0, 0, 0                  // ulCodePageRange2
    884923  };
    885924  GBool missingCmap, missingName, missingPost, missingOS2;
    886   GBool unsortedLoca, badCmapLen, abbrevHMTX;
    887   int nZeroLengthTables;
     925  GBool unsortedLoca, emptyCmap, badCmapLen, abbrevHMTX;
     926  int nZeroLengthTables, nBogusTables;
    888927  int nHMetrics, advWidth, lsb;
    889928  TrueTypeLoca *locaTable;
     
    949988  }
    950989
    951   // check for zero-length tables
    952   nZeroLengthTables = 0;
     990  // check for zero-length tables and bogus tags
     991  nZeroLengthTables = nBogusTables = 0;
    953992  for (i = 0; i < nTables; ++i) {
    954993    if (tables[i].len == 0) {
    955994      ++nZeroLengthTables;
    956     }
    957   }
    958 
    959   // check for an incorrect cmap table length
    960   badCmapLen = gFalse;
     995      if (tables[i].tag == cmapTag) {
     996        missingCmap = gTrue;
     997      } else if (tables[i].tag == nameTag) {
     998        missingName = gTrue;
     999      } else if (tables[i].tag == postTag) {
     1000        missingPost = gTrue;
     1001      } else if (tables[i].tag == os2Tag) {
     1002        missingOS2 = gTrue;
     1003      }
     1004    } else if (!(tables[i].tag & 0xe0000000) ||
     1005               !(tables[i].tag & 0x00e00000) ||
     1006               !(tables[i].tag & 0x0000e000) ||
     1007               !(tables[i].tag & 0x000000e0)) {
     1008      // tags where any of the bytes are < 0x20 are probably bogus
     1009      // (the TrueType spec uses ASCII sequences for tags) -- this
     1010      // catches problems where the number of tables given in the
     1011      // header is too large, and so gibberish data is read at the end
     1012      // of the table directory
     1013      ++nBogusTables;
     1014    }
     1015  }
     1016
     1017  // check for an empty cmap table or an incorrect cmap table length
     1018  emptyCmap = badCmapLen = gFalse;
    9611019  cmapLen = 0; // make gcc happy
    9621020  if (!missingCmap) {
    963     if (nCmaps > 0) {
     1021    if (nCmaps == 0) {
     1022      emptyCmap = gTrue;
     1023    } else {
    9641024      cmapLen = cmaps[0].offset + cmaps[0].len;
    9651025      for (i = 1; i < nCmaps; ++i) {
    966         if (cmaps[i].offset + cmaps[i].len > cmapLen) {
     1026        if (cmaps[i].offset + cmaps[i].len > cmapLen) {
    9671027          cmapLen = cmaps[i].offset + cmaps[i].len;
    968         }
    969       }
    970     }
    971     cmapLen -= tables[cmapIdx].offset;
    972     if (cmapLen > tables[cmapIdx].len) {
    973       badCmapLen = gTrue;
     1028        }
     1029      }
     1030      cmapLen -= tables[cmapIdx].offset;
     1031      if (cmapLen > tables[cmapIdx].len) {
     1032        badCmapLen = gTrue;
     1033      }
    9741034    }
    9751035  }
     
    9841044  // if nothing is broken, just write the TTF file as is
    9851045  if (!missingCmap && !missingName && !missingPost && !missingOS2 &&
    986       !unsortedLoca && !badCmapLen && !abbrevHMTX && nZeroLengthTables == 0 &&
     1046      !unsortedLoca && !emptyCmap && !badCmapLen && !abbrevHMTX &&
     1047      nZeroLengthTables == 0 && nBogusTables == 0 &&
    9871048      !name && !codeToGID) {
    9881049    (*outputFunc)(outputStream, (char *)file, len);
     
    9981059  glyfLen = 0; // make gcc happy
    9991060  if (unsortedLoca) {
    1000     qsort(locaTable, nGlyphs + 1, sizeof(TrueTypeLoca),
    1001           &cmpTrueTypeLocaOffset);
     1061    std::sort(locaTable, locaTable + nGlyphs + 1,
     1062              cmpTrueTypeLocaOffsetFunctor());
    10021063    for (i = 0; i < nGlyphs; ++i) {
    10031064      locaTable[i].len = locaTable[i+1].origOffset - locaTable[i].origOffset;
    10041065    }
    10051066    locaTable[nGlyphs].len = 0;
    1006     qsort(locaTable, nGlyphs + 1, sizeof(TrueTypeLoca),
    1007           &cmpTrueTypeLocaIdx);
     1067    std::sort(locaTable, locaTable + nGlyphs + 1, cmpTrueTypeLocaIdxFunctor());
     1068    // if the last entry in the loca is not the max offset (size of
     1069    // the glyf table), something is wrong -- work around the problem
     1070    // by forcing the last sorted entry to have a zero length
     1071    locaTable[nGlyphs].len = 0;
    10081072    pos = 0;
    10091073    for (i = 0; i <= nGlyphs; ++i) {
     
    11351199    newCmapTab[43] = 0;
    11361200    for (i = 0; i < 256; ++i) {
    1137       newCmapTab[44 + 2*i] = codeToGID[i] >> 8;
    1138       newCmapTab[44 + 2*i + 1] = codeToGID[i] & 0xff;
     1201      if (codeToGID[i] < 0) {
     1202        //~ this may not be correct - we want this character to never be
     1203        //~ displayed, but mapping it to the notdef glyph may result in
     1204        //~ little boxes being displayed
     1205        newCmapTab[44 + 2*i] = 0;
     1206        newCmapTab[44 + 2*i + 1] = 0;
     1207      } else {
     1208        newCmapTab[44 + 2*i] = codeToGID[i] >> 8;
     1209        newCmapTab[44 + 2*i + 1] = codeToGID[i] & 0xff;
     1210      }
    11391211    }
    11401212  } else {
     
    11881260  // - compute new table positions, including 4-byte alignment
    11891261  // - (re)compute table checksums
    1190   nNewTables = nTables - nZeroLengthTables +
     1262  nNewTables = nTables - nZeroLengthTables - nBogusTables +
    11911263               (missingCmap ? 1 : 0) + (missingName ? 1 : 0) +
    11921264               (missingPost ? 1 : 0) + (missingOS2 ? 1 : 0);
     
    11941266  j = 0;
    11951267  for (i = 0; i < nTables; ++i) {
    1196     if (tables[i].len > 0) {
     1268    if (tables[i].len > 0 &&
     1269        (tables[i].tag & 0xe0000000) &&
     1270        (tables[i].tag & 0x00e00000) &&
     1271        (tables[i].tag & 0x0000e000) &&
     1272        (tables[i].tag & 0x000000e0)) {
    11971273      newTables[j] = tables[i];
    11981274      newTables[j].origOffset = tables[i].offset;
    1199       if (checkRegion(tables[i].offset, newTables[i].len)) {
     1275      if (checkRegion(tables[i].offset, tables[i].len)) {
    12001276        newTables[j].checksum =
    12011277            computeTableChecksum(file + tables[i].offset, tables[i].len);
     
    12091285        newTables[j].checksum = computeTableChecksum((Guchar *)newCmapTab,
    12101286                                                     newCmapLen);
     1287      } else if (newTables[j].tag == cmapTag && emptyCmap) {
     1288        newTables[j].checksum = computeTableChecksum((Guchar *)cmapTab,
     1289                                                     sizeof(cmapTab));
     1290        newTables[j].len = sizeof(cmapTab);
    12111291      } else if (newTables[j].tag == cmapTag && badCmapLen) {
    12121292        newTables[j].len = cmapLen;
     
    12731353    ++j;
    12741354  }
    1275   qsort(newTables, nNewTables, sizeof(TrueTypeTable),
    1276         &cmpTrueTypeTableTag);
     1355  std::sort(newTables, newTables + nNewTables, cmpTrueTypeTableTagFunctor());
    12771356  pos = 12 + nNewTables * 16;
    12781357  for (i = 0; i < nNewTables; ++i) {
     
    14251504                               FoFiOutputFunc outputFunc,
    14261505                               void *outputStream) {
    1427   char *name;
     1506  const char *name;
    14281507  GooString *buf;
    14291508  int i;
     
    14521531
    14531532void FoFiTrueType::cvtCharStrings(char **encoding,
    1454                                   Gushort *codeToGID,
     1533                                  int *codeToGID,
    14551534                                  FoFiOutputFunc outputFunc,
    14561535                                  void *outputStream) {
     
    15051584void FoFiTrueType::cvtSfnts(FoFiOutputFunc outputFunc,
    15061585                            void *outputStream, GooString *name,
    1507                             GBool needVerticalMetrics) {
     1586                            GBool needVerticalMetrics,
     1587                            int *maxUsedGlyph) {
    15081588  Guchar headData[54];
    15091589  TrueTypeLoca *locaTable;
     
    15141594  Guint checksum;
    15151595  int nNewTables;
    1516   int length, pos, glyfPos, i, j, k;
     1596  int glyfTableLen, length, pos, glyfPos, i, j, k;
    15171597  Guchar vheaTab[36] = {
    15181598    0, 1, 0, 0,                 // table version number
     
    15501630  headData[8] = headData[9] = headData[10] = headData[11] = (Guchar)0;
    15511631
     1632  // check for a bogus loca format field in the 'head' table
     1633  // (I've encountered fonts with loca format set to 0x0100 instead of 0x0001)
     1634  if (locaFmt != 0 && locaFmt != 1) {
     1635    headData[50] = 0;
     1636    headData[51] = 1;
     1637  }
     1638
    15521639  // read the original 'loca' table, pad entries out to 4 bytes, and
    15531640  // sort it into proper order -- some (non-compliant) fonts have
    15541641  // out-of-order loca tables; in order to correctly handle the case
    15551642  // where (compliant) fonts have empty entries in the middle of the
    1556   // table, cmpTrueTypeLocaPos uses offset as its primary sort key,
     1643  // table, cmpTrueTypeLocaOffset uses offset as its primary sort key,
    15571644  // and idx as its secondary key (ensuring that adjacent entries with
    15581645  // the same pos value remain in the same order)
     
    15601647  i = seekTable("loca");
    15611648  pos = tables[i].offset;
     1649  i = seekTable("glyf");
     1650  glyfTableLen = tables[i].len;
    15621651  ok = gTrue;
    15631652  for (i = 0; i <= nGlyphs; ++i) {
     
    15681657      locaTable[i].origOffset = 2 * getU16BE(pos + i*2, &ok);
    15691658    }
    1570   }
    1571   qsort(locaTable, nGlyphs + 1, sizeof(TrueTypeLoca),
    1572         &cmpTrueTypeLocaOffset);
     1659    if (locaTable[i].origOffset > glyfTableLen) {
     1660      locaTable[i].origOffset = glyfTableLen;
     1661    }
     1662  }
     1663  std::sort(locaTable, locaTable + nGlyphs + 1,
     1664            cmpTrueTypeLocaOffsetFunctor());
    15731665  for (i = 0; i < nGlyphs; ++i) {
    15741666    locaTable[i].len = locaTable[i+1].origOffset - locaTable[i].origOffset;
    15751667  }
    15761668  locaTable[nGlyphs].len = 0;
    1577   qsort(locaTable, nGlyphs + 1, sizeof(TrueTypeLoca),
    1578         &cmpTrueTypeLocaIdx);
     1669  std::sort(locaTable, locaTable + nGlyphs + 1, cmpTrueTypeLocaIdxFunctor());
    15791670  pos = 0;
     1671  *maxUsedGlyph = -1;
    15801672  for (i = 0; i <= nGlyphs; ++i) {
    15811673    locaTable[i].newOffset = pos;
     
    15831675    if (pos & 3) {
    15841676      pos += 4 - (pos & 3);
     1677    }
     1678    if (locaTable[i].len > 0) {
     1679      *maxUsedGlyph = i;
    15851680    }
    15861681  }
     
    16661761        checksum = computeTableChecksum(vheaTab, length);
    16671762      } else if (needVerticalMetrics && i == t42VmtxTable) {
    1668         length = 4 + (nGlyphs - 1) * 4;
     1763        length = 4 + (nGlyphs - 1) * 2;
    16691764        vmtxTab = (Guchar *)gmalloc(length);
    16701765        vmtxTab[0] = advance / 256;
     
    17841879        } else if (needVerticalMetrics && i == t42VmtxTable) {
    17851880          dumpString(vmtxTab, length, outputFunc, outputStream);
    1786           gfree(vmtxTab);
    17871881        }
    17881882      }
     
    17951889  gfree(locaData);
    17961890  gfree(locaTable);
     1891  if (vmtxTab) {
     1892    gfree(vmtxTab);
     1893  }
    17971894}
    17981895
     
    19011998  tables = (TrueTypeTable *)gmallocn(nTables, sizeof(TrueTypeTable));
    19021999  pos += 12;
    1903   int wrongTables = 0;
     2000  j = 0;
    19042001  for (i = 0; i < nTables; ++i) {
    1905     tables[i].tag = getU32BE(pos, &parsedOk);
    1906     tables[i].checksum = getU32BE(pos + 4, &parsedOk);
    1907     tables[i].offset = (int)getU32BE(pos + 8, &parsedOk);
    1908     tables[i].len = (int)getU32BE(pos + 12, &parsedOk);
    1909     if (tables[i].offset + tables[i].len < tables[i].offset ||
    1910         tables[i].offset + tables[i].len > len) {
    1911       i--;
    1912       wrongTables++;
    1913       error(-1, "Found a bad table definition on true type definition, trying to continue...");
     2002    tables[j].tag = getU32BE(pos, &parsedOk);
     2003    tables[j].checksum = getU32BE(pos + 4, &parsedOk);
     2004    tables[j].offset = (int)getU32BE(pos + 8, &parsedOk);
     2005    tables[j].len = (int)getU32BE(pos + 12, &parsedOk);
     2006    if (tables[j].offset + tables[j].len >= tables[j].offset &&
     2007        tables[j].offset + tables[j].len <= len) {
     2008      // ignore any bogus entries in the table directory
     2009      ++j;
    19142010    }
    19152011    pos += 16;
    19162012  }
    1917   nTables -= wrongTables;
    1918   tables = (TrueTypeTable *)greallocn_checkoverflow(tables, nTables, sizeof(TrueTypeTable));
     2013  if (nTables != j) {
     2014    nTables = j;
     2015    tables = (TrueTypeTable *)greallocn_checkoverflow(tables, nTables, sizeof(TrueTypeTable));
     2016  }
    19192017  if (!parsedOk || tables == NULL) {
    19202018    return;
     
    20862184}
    20872185
    2088 int FoFiTrueType::seekTable(char *tag) {
     2186int FoFiTrueType::seekTable(const char *tag) {
    20892187  Guint tagI;
    20902188  int i;
     
    21242222  Only supporting vertical text substitution.
    21252223*/
    2126 int FoFiTrueType::setupGSUB(const char *tagName)
     2224int FoFiTrueType::setupGSUB(const char *scriptName)
     2225{
     2226  return setupGSUB(scriptName, NULL);
     2227}
     2228
     2229/*
     2230  setup GSUB table data
     2231  Only supporting vertical text substitution.
     2232*/
     2233int FoFiTrueType::setupGSUB(const char *scriptName,
     2234                            const char *languageName)
    21272235{
    21282236  Guint gsubTable;
     
    21412249  Guint pos;
    21422250
    2143   if (tagName == 0) {
     2251  if (scriptName == 0) {
    21442252    gsubFeatureTable = 0;
    21452253    return 0;
    21462254  }
    2147   scriptTag = charToTag(tagName);
     2255  scriptTag = charToTag(scriptName);
    21482256  /* read GSUB Header */
    21492257  if ((x = seekTable("GSUB")) < 0) {
     
    21822290  /* use default language system */
    21832291  pos = gsubTable+scriptList+scriptTable;
    2184   langSys = getU16BE(pos,&parsedOk);/* default language system */
     2292  langSys = 0;
     2293  if (languageName) {
     2294    Guint langTag = charToTag(languageName);
     2295    Guint langCount = getU16BE(pos+2,&parsedOk);
     2296    for (i = 0;i < langCount && langSys == 0;i++) {
     2297      tag = getU32BE(pos+4+i*(4+2),&parsedOk);
     2298      if (tag == langTag) {
     2299        langSys = getU16BE(pos+4+i*(4+2)+4,&parsedOk);
     2300      }
     2301    }
     2302  }
     2303  if (langSys == 0) {
     2304    /* default language system */
     2305    langSys = getU16BE(pos,&parsedOk);
     2306  }
    21852307
    21862308  /* read LangSys table */
    21872309  if (langSys == 0) {
    2188     /* no ldefault LangSys */
     2310    /* no default LangSys */
    21892311    return 0;
    21902312  }
     
    23582480    count = getU16BE(pos,&parsedOk);
    23592481    pos += 2;
     2482    // In some poor CJK fonts, key GIDs are not sorted,
     2483    // thus we cannot finish checking even when the range
     2484    // including orgGID seems to have already passed.
    23602485    for (i = 0;i < count;i++) {
    23612486      Guint gid;
     
    23662491        /* found */
    23672492        index = i;
    2368         break;
    2369       } else if (gid > orgGID) {
    2370         /* not found */
    23712493        break;
    23722494      }
     
    23862508      startIndex = getU16BE(pos,&parsedOk);
    23872509      pos += 2;
     2510      // In some poor CJK fonts, key GIDs are not sorted,
     2511      // thus we cannot finish checking even when the range
     2512      // including orgGID seems to have already passed.
    23882513      if (startGID <= orgGID && orgGID <= endGID) {
    23892514        /* found */
    23902515        index = startIndex+orgGID-startGID;
    23912516        break;
    2392       } else if (orgGID <= endGID) {
    2393         /* not found */
    2394         break;
    23952517      }
    23962518    }
  • trunk/poppler/mypoppler/fofi/FoFiTrueType.h

    r497 r515  
    1717// Copyright (C) 2007 Koji Otani <sho@bbr.jp>
    1818// Copyright (C) 2011 Albert Astals Cid <aacid@kde.org>
     19// Copyright (C) 2012 Suzuki Toshiya <mpsuzuki@hiroshima-u.ac.jp>
    1920//
    2021// To see a description of the changes please see the Changelog file that
     
    7273
    7374  // Return the GID corresponding to <c> according to the <i>th cmap.
    74   Gushort mapCodeToGID(int i, Guint c);
     75  int mapCodeToGID(int i, Guint c);
    7576
    7677  // map gid to vertical glyph gid if exist.
     
    8687  // CIDs in *<nCIDs>.  This is only useful for CID fonts.  (Only
    8788  // useful for OpenType CFF fonts.)
    88   Gushort *getCIDToGIDMap(int *nCIDs);
     89  int *getCIDToGIDMap(int *nCIDs);
    8990
    9091  // Returns the least restrictive embedding licensing right (as
     
    9798  int getEmbeddingRights();
    9899
     100  // Return the font matrix as an array of six numbers.  (Only useful
     101  // for OpenType CFF fonts.)
     102  void getFontMatrix(double *mat);
     103
    99104  // Convert to a Type 42 font, suitable for embedding in a PostScript
    100105  // file.  <psName> will be used as the PostScript font name (so we
     
    105110  // (Not useful for OpenType CFF fonts.)
    106111  void convertToType42(char *psName, char **encoding,
    107                        Gushort *codeToGID,
     112                       int *codeToGID,
    108113                       FoFiOutputFunc outputFunc, void *outputStream);
    109114
     
    115120  // non-NULL, it will be used as the PostScript font name.  (Only
    116121  // useful for OpenType CFF fonts.)
    117   void convertToType1(char *psName, char **newEncoding, GBool ascii,
     122  void convertToType1(char *psName, const char **newEncoding, GBool ascii,
    118123                      FoFiOutputFunc outputFunc, void *outputStream);
    119124
     
    123128  // font).  The <cidMap> array maps CIDs to GIDs; it has <nCIDs>
    124129  // entries.  (Not useful for OpenType CFF fonts.)
    125   void convertToCIDType2(char *psName, Gushort *cidMap, int nCIDs,
     130  void convertToCIDType2(char *psName, int *cidMap, int nCIDs,
    126131                         GBool needVerticalMetrics,
    127132                         FoFiOutputFunc outputFunc, void *outputStream);
     
    130135  // PostScript file.  <psName> will be used as the PostScript font
    131136  // name.  (Only useful for OpenType CFF fonts.)
    132   void convertToCIDType0(char *psName,
     137  void convertToCIDType0(char *psName, int *cidMap, int nCIDs,
    133138                         FoFiOutputFunc outputFunc, void *outputStream);
    134139
     
    138143  // table in the font).  The <cidMap> array maps CIDs to GIDs; it has
    139144  // <nCIDs> entries.  (Not useful for OpenType CFF fonts.)
    140   void convertToType0(char *psName, Gushort *cidMap, int nCIDs,
     145  void convertToType0(char *psName, int *cidMap, int nCIDs,
    141146                      GBool needVerticalMetrics,
    142147                      FoFiOutputFunc outputFunc, void *outputStream);
     
    145150  // embedding in a PostScript file.  <psName> will be used as the
    146151  // PostScript font name.  (Only useful for OpenType CFF fonts.)
    147   void convertToType0(char *psName,
     152  void convertToType0(char *psName, int *cidMap, int nCIDs,
    148153                      FoFiOutputFunc outputFunc, void *outputStream);
    149154
     
    155160  // for OpenType CFF fonts.)
    156161  void writeTTF(FoFiOutputFunc outputFunc, void *outputStream,
    157                 char *name = NULL, Gushort *codeToGID = NULL);
    158 
    159   int setupGSUB(const char *tagName);
     162                char *name = NULL, int *codeToGID = NULL);
     163
     164  // Returns a pointer to the CFF font embedded in this OpenType font.
     165  // If successful, sets *<start> and *<length>, and returns true.
     166  // Otherwise returns false.  (Only useful for OpenType CFF fonts).
     167  GBool getCFFBlock(char **start, int *length);
     168
     169  // setup vert/vrt2 GSUB for default lang
     170  int setupGSUB(const char *scriptName);
     171
     172  // setup vert/vrt2 GSUB for specified lang
     173  int setupGSUB(const char *scriptName, const char* languageName);
     174
    160175private:
    161176
     
    165180                   void *outputStream);
    166181  void cvtCharStrings(char **encoding,
    167                       Gushort *codeToGID,
     182                      int *codeToGID,
    168183                      FoFiOutputFunc outputFunc,
    169184                      void *outputStream);
    170185  void cvtSfnts(FoFiOutputFunc outputFunc,
    171186                void *outputStream, GooString *name,
    172                 GBool needVerticalMetrics);
     187                GBool needVerticalMetrics,
     188                int *maxUsedGlyph);
    173189  void dumpString(Guchar *s, int length,
    174190                  FoFiOutputFunc outputFunc,
     
    177193  void parse();
    178194  void readPostTable();
    179   int seekTable(char *tag);
     195  int seekTable(const char *tag);
    180196  Guint charToTag(const char *tagName);
    181197  Guint doMapToVertGID(Guint orgGID);
  • trunk/poppler/mypoppler/fofi/FoFiType1.cc

    r470 r515  
    6060  name = NULL;
    6161  encoding = NULL;
     62  fontMatrix[0] = 0.001;
     63  fontMatrix[1] = 0;
     64  fontMatrix[2] = 0;
     65  fontMatrix[3] = 0.001;
     66  fontMatrix[4] = 0;
     67  fontMatrix[5] = 0;
    6268  parsed = gFalse;
     69  undoPFB();
    6370}
    6471
     
    9198}
    9299
    93 void FoFiType1::writeEncoded(char **newEncoding,
     100void FoFiType1::getFontMatrix(double *mat) {
     101  int i;
     102
     103  if (!parsed) {
     104    parse();
     105  }
     106  for (i = 0; i < 6; ++i) {
     107    mat[i] = fontMatrix[i];
     108  }
     109}
     110
     111void FoFiType1::writeEncoded(const char **newEncoding,
    94112                             FoFiOutputFunc outputFunc, void *outputStream) {
    95113  char buf[512];
     
    194212  char buf[256];
    195213  char c;
    196   int n, code, i, j;
     214  int n, code, base, i, j;
    197215  char *tokptr;
    198 
     216  GBool gotMatrix;
     217
     218  gotMatrix = gFalse;
    199219  for (i = 1, line = (char *)file;
    200220       i <= 100 && line && (!name || !encoding);
     
    214234    } else if (!encoding &&
    215235               !strncmp(line, "/Encoding StandardEncoding def", 30)) {
    216       encoding = fofiType1StandardEncoding;
     236      encoding = (char **)fofiType1StandardEncoding;
    217237    } else if (!encoding &&
    218238               !strncmp(line, "/Encoding 256 array", 19)) {
     
    224244           j < 300 && line && (line1 = getNextLine(line));
    225245           ++j, line = line1) {
    226         if ((n = line1 - line) > 255) {
    227           error(-1, "FoFiType1::parse a line has more than 255 characters, we don't support this");
     246        if ((n = (int)(line1 - line)) > 255) {
     247          error(errSyntaxWarning, -1, "FoFiType1::parse a line has more than 255 characters, we don't support this");
    228248          n = 255;
    229249        }
     
    232252        for (p = buf; *p == ' ' || *p == '\t'; ++p) ;
    233253        if (!strncmp(p, "dup", 3)) {
    234           for (p += 3; *p == ' ' || *p == '\t'; ++p) ;
    235           for (p2 = p; *p2 >= '0' && *p2 <= '9'; ++p2) ;
    236           if (*p2) {
    237             c = *p2; // store it so we can recover it after atoi
    238             *p2 = '\0'; // terminate p so atoi works
    239             code = atoi(p);
    240             *p2 = c;
    241             if (code == 8 && *p2 == '#') {
    242               code = 0;
    243               for (++p2; *p2 >= '0' && *p2 <= '7'; ++p2) {
    244                 code = code * 8 + (*p2 - '0');
    245               }
    246             }
    247             if (likely(code < 256 && code >= 0)) {
    248               for (p = p2; *p == ' ' || *p == '\t'; ++p) ;
    249               if (*p == '/') {
    250                 ++p;
    251                 for (p2 = p; *p2 && *p2 != ' ' && *p2 != '\t'; ++p2) ;
    252                 c = *p2; // store it so we can recover it after copyString
    253                 *p2 = '\0'; // terminate p so copyString works
    254                 encoding[code] = copyString(p);
    255                 *p2 = c;
    256                 p = p2;
    257                 for (; *p == ' ' || *p == '\t'; ++p); // eat spaces between string and put
    258                 if (!strncmp(p, "put", 3)) {
    259                   // eat put and spaces and newlines after put
    260                   for (p += 3; *p == ' ' || *p == '\t' || *p == '\n' || *p == '\r'; ++p);
    261                   if (*p)
    262                   {
    263                     // there is still something after the definition
    264                     // there might be another definition in this line
    265                     // so move line1 to the end of our parsing
    266                     // so we start in the potential next definition in the next loop
    267                     line1 = &line[p - buf];
    268                   }
    269                 } else {
    270                   error(-1, "FoFiType1::parse no put after dup");
    271                 }
    272               }
     254          while (1) {
     255            p += 3;
     256            for (; *p == ' ' || *p == '\t'; ++p) ;
     257            code = 0;
     258            if (*p == '8' && p[1] == '#') {
     259              base = 8;
     260              p += 2;
     261            } else if (*p >= '0' && *p <= '9') {
     262              base = 10;
     263            } else {
     264              break;
     265            }
     266            for (; *p >= '0' && *p < '0' + base; ++p) {
     267              code = code * base + (*p - '0');
     268            }
     269            for (; *p == ' ' || *p == '\t'; ++p) ;
     270            if (*p != '/') {
     271              break;
     272            }
     273            ++p;
     274            for (p2 = p; *p2 && *p2 != ' ' && *p2 != '\t'; ++p2) ;
     275            if (code >= 0 && code < 256) {
     276              c = *p2;
     277              *p2 = '\0';
     278              encoding[code] = copyString(p);
     279              *p2 = c;
     280            }
     281            for (p = p2; *p == ' ' || *p == '\t'; ++p) ;
     282            if (strncmp(p, "put", 3)) {
     283              break;
     284            }
     285            for (p += 3; *p == ' ' || *p == '\t'; ++p) ;
     286            if (strncmp(p, "dup", 3)) {
     287              break;
    273288            }
    274289          }
     
    282297      //~ check for getinterval/putinterval junk
    283298
     299    } else if (!gotMatrix && !strncmp(line, "/FontMatrix", 11)) {
     300      strncpy(buf, line + 11, 255);
     301      buf[255] = '\0';
     302      if ((p = strchr(buf, '['))) {
     303        ++p;
     304        if ((p2 = strchr(p, ']'))) {
     305          *p2 = '\0';
     306          for (j = 0; j < 6; ++j) {
     307            if ((p = strtok(j == 0 ? p : (char *)NULL, " \t\n\r"))) {
     308              fontMatrix[j] = atof(p);
     309            } else {
     310              break;
     311            }
     312          }
     313        }
     314      }
     315      gotMatrix = gTrue;
     316
    284317    } else {
    285318      line = getNextLine(line);
     
    289322  parsed = gTrue;
    290323}
     324
     325// Undo the PFB encoding, i.e., remove the PFB headers.
     326void FoFiType1::undoPFB() {
     327  GBool ok;
     328  Guchar *file2;
     329  int pos1, pos2, type;
     330  Guint segLen;
     331
     332  ok = gTrue;
     333  if (getU8(0, &ok) != 0x80 || !ok) {
     334    return;
     335  }
     336  file2 = (Guchar *)gmalloc(len);
     337  pos1 = pos2 = 0;
     338  while (getU8(pos1, &ok) == 0x80 && ok) {
     339    type = getU8(pos1 + 1, &ok);
     340    if (type < 1 || type > 2 || !ok) {
     341      break;
     342    }
     343    segLen = getU32LE(pos1 + 2, &ok);
     344    pos1 += 6;
     345    if (!ok || !checkRegion(pos1, segLen)) {
     346      break;
     347    }
     348    memcpy(file2 + pos2, file + pos1, segLen);
     349    pos1 += segLen;
     350    pos2 += segLen;
     351  }
     352  if (freeFileData) {
     353    gfree(fileData);
     354  }
     355  file = fileData = file2;
     356  freeFileData = gTrue;
     357  len = pos2;
     358}
  • trunk/poppler/mypoppler/fofi/FoFiType1.h

    r2 r515  
    3939  char **getEncoding();
    4040
     41  // Return the font matrix as an array of six numbers.
     42  void getFontMatrix(double *mat);
     43
    4144  // Write a version of the Type 1 font file with a new encoding.
    42   void writeEncoded(char **newEncoding,
     45  void writeEncoded(const char **newEncoding,
    4346                    FoFiOutputFunc outputFunc, void *outputStream);
    4447
     
    4952  char *getNextLine(char *line);
    5053  void parse();
     54  void undoPFB();
    5155
    5256  char *name;
    5357  char **encoding;
     58  double fontMatrix[6];
    5459  GBool parsed;
    5560};
  • trunk/poppler/mypoppler/fofi/FoFiType1C.cc

    r461 r515  
    117117}
    118118
    119 Gushort *FoFiType1C::getCIDToGIDMap(int *nCIDs) {
    120   Gushort *map;
     119GooString *FoFiType1C::getGlyphName(int gid) {
     120  char buf[256];
     121  GBool ok;
     122
     123  ok = gTrue;
     124  getString(charset[gid], buf, &ok);
     125  if (!ok) {
     126    return NULL;
     127  }
     128  return new GooString(buf);
     129}
     130
     131int *FoFiType1C::getCIDToGIDMap(int *nCIDs) {
     132  int *map;
    121133  int n, i;
    122134
     
    136148  }
    137149  ++n;
    138   map = (Gushort *)gmallocn(n, sizeof(Gushort));
    139   memset(map, 0, n * sizeof(Gushort));
     150  map = (int *)gmallocn(n, sizeof(int));
     151  memset(map, 0, n * sizeof(int));
    140152  for (i = 0; i < nGlyphs; ++i) {
    141153    map[charset[i]] = i;
     
    145157}
    146158
    147 void FoFiType1C::convertToType1(char *psName, char **newEncoding, GBool ascii,
     159void FoFiType1C::getFontMatrix(double *mat) {
     160  int i;
     161
     162  if (topDict.firstOp == 0x0c1e && privateDicts[0].hasFontMatrix) {
     163    if (topDict.hasFontMatrix) {
     164      mat[0] = topDict.fontMatrix[0] * privateDicts[0].fontMatrix[0] +
     165               topDict.fontMatrix[1] * privateDicts[0].fontMatrix[2];
     166      mat[1] = topDict.fontMatrix[0] * privateDicts[0].fontMatrix[1] +
     167               topDict.fontMatrix[1] * privateDicts[0].fontMatrix[3];
     168      mat[2] = topDict.fontMatrix[2] * privateDicts[0].fontMatrix[0] +
     169               topDict.fontMatrix[3] * privateDicts[0].fontMatrix[2];
     170      mat[3] = topDict.fontMatrix[2] * privateDicts[0].fontMatrix[1] +
     171               topDict.fontMatrix[3] * privateDicts[0].fontMatrix[3];
     172      mat[4] = topDict.fontMatrix[4] * privateDicts[0].fontMatrix[0] +
     173               topDict.fontMatrix[5] * privateDicts[0].fontMatrix[2];
     174      mat[5] = topDict.fontMatrix[4] * privateDicts[0].fontMatrix[1] +
     175               topDict.fontMatrix[5] * privateDicts[0].fontMatrix[3];
     176    } else {
     177      for (i = 0; i < 6; ++i) {
     178        mat[i] = privateDicts[0].fontMatrix[i];
     179      }
     180    }
     181  } else {
     182    for (i = 0; i < 6; ++i) {
     183      mat[i] = topDict.fontMatrix[i];
     184    }
     185  }
     186}
     187
     188void FoFiType1C::convertToType1(char *psName, const char **newEncoding, GBool ascii,
    148189                                FoFiOutputFunc outputFunc,
    149190                                void *outputStream) {
     
    154195  GooString *buf;
    155196  char buf2[256];
    156   char **enc;
     197  const char **enc;
    157198  GBool ok;
    158199  int i;
     
    180221  (*outputFunc)(outputStream, "/FontInfo 10 dict dup begin\n", 28);
    181222  if (topDict.versionSID != 0) {
    182     (*outputFunc)(outputStream, "/version (", 10);
    183     (*outputFunc)(outputStream, buf2, strlen(buf2));
    184     (*outputFunc)(outputStream, ") readonly def\n", 15);
     223    (*outputFunc)(outputStream, "/version ", 9);
     224    writePSString(buf2, outputFunc, outputStream);
     225    (*outputFunc)(outputStream, " readonly def\n", 14);
    185226  }
    186227  if (topDict.noticeSID != 0) {
    187228    getString(topDict.noticeSID, buf2, &ok);
    188     (*outputFunc)(outputStream, "/Notice (", 9);
    189     (*outputFunc)(outputStream, buf2, strlen(buf2));
    190     (*outputFunc)(outputStream, ") readonly def\n", 15);
     229    (*outputFunc)(outputStream, "/Notice ", 8);
     230    writePSString(buf2, outputFunc, outputStream);
     231    (*outputFunc)(outputStream, " readonly def\n", 14);
    191232  }
    192233  if (topDict.copyrightSID != 0) {
    193234    getString(topDict.copyrightSID, buf2, &ok);
    194     (*outputFunc)(outputStream, "/Copyright (", 12);
    195     (*outputFunc)(outputStream, buf2, strlen(buf2));
    196     (*outputFunc)(outputStream, ") readonly def\n", 15);
     235    (*outputFunc)(outputStream, "/Copyright ", 11);
     236    writePSString(buf2, outputFunc, outputStream);
     237    (*outputFunc)(outputStream, " readonly def\n", 14);
    197238  }
    198239  if (topDict.fullNameSID != 0) {
    199240    getString(topDict.fullNameSID, buf2, &ok);
    200     (*outputFunc)(outputStream, "/FullName (", 11);
    201     (*outputFunc)(outputStream, buf2, strlen(buf2));
    202     (*outputFunc)(outputStream, ") readonly def\n", 15);
     241    (*outputFunc)(outputStream, "/FullName ", 10);
     242    writePSString(buf2, outputFunc, outputStream);
     243    (*outputFunc)(outputStream, " readonly def\n", 14);
    203244  }
    204245  if (topDict.familyNameSID != 0) {
    205246    getString(topDict.familyNameSID, buf2, &ok);
    206     (*outputFunc)(outputStream, "/FamilyName (", 13);
    207     (*outputFunc)(outputStream, buf2, strlen(buf2));
    208     (*outputFunc)(outputStream, ") readonly def\n", 15);
     247    (*outputFunc)(outputStream, "/FamilyName ", 12);
     248    writePSString(buf2, outputFunc, outputStream);
     249    (*outputFunc)(outputStream, " readonly def\n", 14);
    209250  }
    210251  if (topDict.weightSID != 0) {
    211252    getString(topDict.weightSID, buf2, &ok);
    212     (*outputFunc)(outputStream, "/Weight (", 9);
    213     (*outputFunc)(outputStream, buf2, strlen(buf2));
    214     (*outputFunc)(outputStream, ") readonly def\n", 15);
     253    (*outputFunc)(outputStream, "/Weight ", 8);
     254    writePSString(buf2, outputFunc, outputStream);
     255    (*outputFunc)(outputStream, " readonly def\n", 14);
    215256  }
    216257  if (topDict.isFixedPitch) {
     
    266307    (*outputFunc)(outputStream,
    267308                  "0 1 255 {1 index exch /.notdef put} for\n", 40);
    268     enc = newEncoding ? newEncoding : encoding;
     309    enc = newEncoding ? newEncoding : (const char **)encoding;
    269310    for (i = 0; i < 256; ++i) {
    270311      if (enc[i]) {
     
    445486}
    446487
    447 void FoFiType1C::convertToCIDType0(char *psName,
     488void FoFiType1C::convertToCIDType0(char *psName, int *codeMap, int nCodes,
    448489                                   FoFiOutputFunc outputFunc,
    449490                                   void *outputStream) {
     
    460501
    461502  // compute the CID count and build the CID-to-GID mapping
    462   nCIDs = 0;
    463   for (i = 0; i < nGlyphs; ++i) {
    464     if (charset[i] >= nCIDs) {
    465       nCIDs = charset[i] + 1;
    466     }
    467   }
    468   cidMap = (int *)gmallocn(nCIDs, sizeof(int));
    469   for (i = 0; i < nCIDs; ++i) {
    470     cidMap[i] = -1;
    471   }
    472   for (i = 0; i < nGlyphs; ++i) {
    473     cidMap[charset[i]] = i;
     503  if (codeMap) {
     504    nCIDs = nCodes;
     505    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     506    for (i = 0; i < nCodes; ++i) {
     507      if (codeMap[i] >= 0 && codeMap[i] < nGlyphs) {
     508        cidMap[i] = codeMap[i];
     509      } else {
     510        cidMap[i] = -1;
     511      }
     512    }
     513  } else if (topDict.firstOp == 0x0c1e) {
     514    nCIDs = 0;
     515    for (i = 0; i < nGlyphs; ++i) {
     516      if (charset[i] >= nCIDs) {
     517        nCIDs = charset[i] + 1;
     518      }
     519    }
     520    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     521    for (i = 0; i < nCIDs; ++i) {
     522      cidMap[i] = -1;
     523    }
     524    for (i = 0; i < nGlyphs; ++i) {
     525      cidMap[charset[i]] = i;
     526    }
     527  } else {
     528    nCIDs = nGlyphs;
     529    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     530    for (i = 0; i < nCIDs; ++i) {
     531      cidMap[i] = i;
     532    }
    474533  }
    475534
     
    483542      getIndexVal(&charStringsIdx, gid, &val, &ok);
    484543      if (ok) {
    485         getIndex(privateDicts[fdSelect[gid]].subrsOffset, &subrIdx, &ok);
     544        getIndex(privateDicts[fdSelect ? fdSelect[gid] : 0].subrsOffset,
     545                 &subrIdx, &ok);
    486546        if (!ok) {
    487547          subrIdx.pos = -1;
    488548        }
    489549        cvtGlyph(val.pos, val.len, charStrings,
    490                  &subrIdx, &privateDicts[fdSelect[gid]], gTrue);
     550                 &subrIdx, &privateDicts[fdSelect ? fdSelect[gid] : 0], gTrue);
    491551      }
    492552    }
     
    733793  for (i = 0; i <= nCIDs; i += 6) {
    734794    for (j = 0; j < 6 && i+j <= nCIDs; ++j) {
    735       if (i+j < nCIDs && cidMap[i+j] >= 0) {
     795      if (i+j < nCIDs && cidMap[i+j] >= 0 && fdSelect) {
    736796        buf2[0] = (char)fdSelect[cidMap[i+j]];
    737797      } else {
     
    771831}
    772832
    773 void FoFiType1C::convertToType0(char *psName,
     833void FoFiType1C::convertToType0(char *psName, int *codeMap, int nCodes,
    774834                                FoFiOutputFunc outputFunc,
    775835                                void *outputStream) {
     
    784844
    785845  // compute the CID count and build the CID-to-GID mapping
    786   nCIDs = 0;
    787   for (i = 0; i < nGlyphs; ++i) {
    788     if (charset[i] >= nCIDs) {
    789       nCIDs = charset[i] + 1;
    790     }
    791   }
    792   cidMap = (int *)gmallocn(nCIDs, sizeof(int));
    793   for (i = 0; i < nCIDs; ++i) {
    794     cidMap[i] = -1;
    795   }
    796   for (i = 0; i < nGlyphs; ++i) {
    797     cidMap[charset[i]] = i;
     846  if (codeMap) {
     847    nCIDs = nCodes;
     848    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     849    for (i = 0; i < nCodes; ++i) {
     850      if (codeMap[i] >= 0 && codeMap[i] < nGlyphs) {
     851        cidMap[i] = codeMap[i];
     852      } else {
     853        cidMap[i] = -1;
     854      }
     855    }
     856  } else if (topDict.firstOp == 0x0c1e) {
     857    nCIDs = 0;
     858    for (i = 0; i < nGlyphs; ++i) {
     859      if (charset[i] >= nCIDs) {
     860        nCIDs = charset[i] + 1;
     861      }
     862    }
     863    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     864    for (i = 0; i < nCIDs; ++i) {
     865      cidMap[i] = -1;
     866    }
     867    for (i = 0; i < nGlyphs; ++i) {
     868      cidMap[charset[i]] = i;
     869    }
     870  } else {
     871    nCIDs = nGlyphs;
     872    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
     873    for (i = 0; i < nCIDs; ++i) {
     874      cidMap[i] = i;
     875    }
    798876  }
    799877
     
    805883    //~ font up by FD; as a kludge we ignore CID 0, which is .notdef
    806884    fd = 0;
    807     if (fdSelect != NULL) {
     885    // if fdSelect is NULL, we have an 8-bit font, so just leave fd=0
     886    if (fdSelect) {
    808887      for (j = i==0 ? 1 : 0; j < 256 && i+j < nCIDs; ++j) {
    809888        if (cidMap[i+j] >= 0) {
     
    10841163}
    10851164
    1086 void FoFiType1C::eexecCvtGlyph(Type1CEexecBuf *eb, char *glyphName,
     1165void FoFiType1C::eexecCvtGlyph(Type1CEexecBuf *eb, const char *glyphName,
    10871166                               int offset, int nBytes,
    10881167                               Type1CIndex *subrIdx,
     
    18101889}
    18111890
    1812 void FoFiType1C::eexecWrite(Type1CEexecBuf *eb, char *s) {
     1891void FoFiType1C::eexecWrite(Type1CEexecBuf *eb, const char *s) {
    18131892  Guchar *p;
    18141893  Guchar x;
     
    18541933}
    18551934
     1935void FoFiType1C::writePSString(char *s, FoFiOutputFunc outputFunc,
     1936                               void *outputStream) {
     1937  char buf[80];
     1938  char *p;
     1939  int i, c;
     1940
     1941  i = 0;
     1942  buf[i++] = '(';
     1943  for (p = s; *p; ++p) {
     1944    c = *p & 0xff;
     1945    if (c == '(' || c == ')' || c == '\\') {
     1946      buf[i++] = '\\';
     1947      buf[i++] = c;
     1948    } else if (c < 0x20 || c >= 0x80) {
     1949      buf[i++] = '\\';
     1950      buf[i++] = '0' + ((c >> 6) & 7);
     1951      buf[i++] = '0' + ((c >> 3) & 7);
     1952      buf[i++] = '0' + (c & 7);
     1953    } else {
     1954      buf[i++] = c;
     1955    }
     1956    if (i >= 64) {
     1957      buf[i++] = '\\';
     1958      buf[i++] = '\n';
     1959      (*outputFunc)(outputStream, buf, i);
     1960      i = 0;
     1961    }
     1962  }
     1963  buf[i++] = ')';
     1964  (*outputFunc)(outputStream, buf, i);
     1965}
     1966
    18561967GBool FoFiType1C::parse() {
    18571968  Type1CIndex fdIdx;
     
    19142025  // for 8-bit fonts: read the private dict
    19152026  } else {
     2027    nFDs = 1;
    19162028    privateDicts = (Type1CPrivateDict *)gmalloc(sizeof(Type1CPrivateDict));
    19172029    readPrivateDict(topDict.privateOffset, topDict.privateSize,
     
    20652177
    20662178  hasFontMatrix = gFalse;
     2179  fontMatrix[0] = fontMatrix[1] = fontMatrix[2] = 0; // make gcc happy
     2180  fontMatrix[3] = fontMatrix[4] = fontMatrix[5] = 0;
    20672181  pSize = pOffset = 0;
    20682182  pos = offset;
     
    22792393
    22802394  if (topDict.encodingOffset == 0) {
    2281     encoding = fofiType1StandardEncoding;
     2395    encoding = (char **)fofiType1StandardEncoding;
    22822396
    22832397  } else if (topDict.encodingOffset == 1) {
    2284     encoding = fofiType1ExpertEncoding;
     2398    encoding = (char **)fofiType1ExpertEncoding;
    22852399
    22862400  } else {
     
    26022716  int n;
    26032717
    2604   if (sid < 391) {
     2718  if (sid < 0) {
     2719    buf[0] = '\0';
     2720  } else if (sid < 391) {
    26052721    strcpy(buf, fofiType1CStdStrings[sid]);
    26062722  } else {
  • trunk/poppler/mypoppler/fofi/FoFiType1C.h

    r257 r515  
    162162  char **getEncoding();
    163163
     164  // Get the glyph names.
     165  int getNumGlyphs() { return nGlyphs; }
     166  GooString *getGlyphName(int gid);
     167
    164168  // Return the mapping from CIDs to GIDs, and return the number of
    165169  // CIDs in *<nCIDs>.  This is only useful for CID fonts.
    166   Gushort *getCIDToGIDMap(int *nCIDs);
     170  int *getCIDToGIDMap(int *nCIDs);
     171
     172  // Return the font matrix as an array of six numbers.
     173  void getFontMatrix(double *mat);
    167174
    168175  // Convert to a Type 1 font, suitable for embedding in a PostScript
     
    172179  // otherwise it will be left as binary data.  If <psName> is non-NULL,
    173180  // it will be used as the PostScript font name.
    174   void convertToType1(char *psName, char **newEncoding, GBool ascii,
     181  void convertToType1(char *psName, const char **newEncoding, GBool ascii,
    175182                      FoFiOutputFunc outputFunc, void *outputStream);
    176183
    177184  // Convert to a Type 0 CIDFont, suitable for embedding in a
    178185  // PostScript file.  <psName> will be used as the PostScript font
    179   // name.
    180   void convertToCIDType0(char *psName,
     186  // name.  There are three cases for the CID-to-GID mapping:
     187  // (1) if <codeMap> is non-NULL, then it is the CID-to-GID mapping
     188  // (2) if <codeMap> is NULL and this is a CID CFF font, then the
     189  //     font's internal CID-to-GID mapping is used
     190  // (3) is <codeMap> is NULL and this is an 8-bit CFF font, then
     191  //     the identity CID-to-GID mapping is used
     192  void convertToCIDType0(char *psName, int *codeMap, int nCodes,
    181193                         FoFiOutputFunc outputFunc, void *outputStream);
    182194
    183195  // Convert to a Type 0 (but non-CID) composite font, suitable for
    184196  // embedding in a PostScript file.  <psName> will be used as the
    185   // PostScript font name.
    186   void convertToType0(char *psName,
     197  // PostScript font name.  There are three cases for the CID-to-GID
     198  // mapping:
     199  // (1) if <codeMap> is non-NULL, then it is the CID-to-GID mapping
     200  // (2) if <codeMap> is NULL and this is a CID CFF font, then the
     201  //     font's internal CID-to-GID mapping is used
     202  // (3) is <codeMap> is NULL and this is an 8-bit CFF font, then
     203  //     the identity CID-to-GID mapping is used
     204  void convertToType0(char *psName, int *codeMap, int nCodes,
    187205                      FoFiOutputFunc outputFunc, void *outputStream);
    188206
     
    190208
    191209  FoFiType1C(char *fileA, int lenA, GBool freeFileDataA);
    192   void eexecCvtGlyph(Type1CEexecBuf *eb, char *glyphName,
     210  void eexecCvtGlyph(Type1CEexecBuf *eb, const char *glyphName,
    193211                     int offset, int nBytes,
    194212                     Type1CIndex *subrIdx,
     
    200218                     Type1CPrivateDict *pDict);
    201219  void cvtNum(double x, GBool isFP, GooString *charBuf);
    202   void eexecWrite(Type1CEexecBuf *eb, char *s);
     220  void eexecWrite(Type1CEexecBuf *eb, const char *s);
    203221  void eexecWriteCharstring(Type1CEexecBuf *eb, Guchar *s, int n);
     222  void writePSString(char *s, FoFiOutputFunc outputFunc, void *outputStream);
    204223  GBool parse();
    205224  void readTopDict();
Note: See TracChangeset for help on using the changeset viewer.