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

updated poppler to 0.20.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.