pdf2swf/xpdf/CharCodeToUnicode.cc

   1 //========================================================================
   2 //
   3 // CharCodeToUnicode.cc
   4 //
   5 // Copyright 2001-2002 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #ifdef __GNUC__
  10 #pragma implementation
  11 #endif
  12
  13 #include <aconf.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include "gmem.h"
  17 #include "gfile.h"
  18 #include "GString.h"
  19 #include "Error.h"
  20 #include "GlobalParams.h"
  21 #include "PSTokenizer.h"
  22 #include "CharCodeToUnicode.h"
  23
  24 //------------------------------------------------------------------------
  25
  26 #define maxUnicodeString 8
  27
  28 struct CharCodeToUnicodeString {
  29   CharCode c;
  30   Unicode u[maxUnicodeString];
  31   int len;
  32 };
  33
  34 //------------------------------------------------------------------------
  35
  36 static int getCharFromString(void *data) {
  37   char *p;
  38   int c;
  39
  40   p = *(char **)data;
  41   if (*p) {
  42     c = *p++;
  43     *(char **)data = p;
  44   } else {
  45     c = EOF;
  46   }
  47   return c;
  48 }
  49
  50 static int getCharFromFile(void *data) {
  51   return fgetc((FILE *)data);
  52 }
  53
  54 //------------------------------------------------------------------------
  55
  56 CharCodeToUnicode *CharCodeToUnicode::parseCIDToUnicode(GString *collectionA) {
  57   FILE *f;
  58   Unicode *mapA;
  59   CharCode size, mapLenA;
  60   char buf[64];
  61   Unicode u;
  62   CharCodeToUnicode *ctu;
  63
  64   if (!(f = globalParams->getCIDToUnicodeFile(collectionA))) {
  65     error(-1, "Couldn't find cidToUnicode file for the '%s' collection",
  66           collectionA->getCString());
  67     return NULL;
  68   }
  69
  70   size = 32768;
  71   mapA = (Unicode *)gmalloc(size * sizeof(Unicode));
  72   mapLenA = 0;
  73
  74   while (getLine(buf, sizeof(buf), f)) {
  75     if (mapLenA == size) {
  76       size *= 2;
  77       mapA = (Unicode *)grealloc(mapA, size * sizeof(Unicode));
  78     }
  79     if (sscanf(buf, "%x", &u) == 1) {
  80       mapA[mapLenA] = u;
  81     } else {
  82       error(-1, "Bad line (%d) in cidToUnicode file for the '%s' collection",
  83             (int)(mapLenA + 1), collectionA->getCString());
  84       mapA[mapLenA] = 0;
  85     }
  86     ++mapLenA;
  87   }
  88
  89   ctu = new CharCodeToUnicode(collectionA->copy(), mapA, mapLenA, gTrue,
  90                               NULL, 0);
  91   gfree(mapA);
  92   return ctu;
  93 }
  94
  95 CharCodeToUnicode *CharCodeToUnicode::make8BitToUnicode(Unicode *toUnicode) {
  96   return new CharCodeToUnicode(NULL, toUnicode, 256, gTrue, NULL, 0);
  97 }
  98
  99 CharCodeToUnicode *CharCodeToUnicode::parseCMap(GString *buf, int nBits) {
 100   CharCodeToUnicode *ctu;
 101   char *p;
 102
 103   ctu = new CharCodeToUnicode(NULL);
 104   p = buf->getCString();
 105   ctu->parseCMap1(&getCharFromString, &p, nBits);
 106   return ctu;
 107 }
 108
 109 void CharCodeToUnicode::parseCMap1(int (*getCharFunc)(void *), void *data,
 110                                    int nBits) {
 111   PSTokenizer *pst;
 112   char tok1[256], tok2[256], tok3[256];
 113   int nDigits, n1, n2, n3;
 114   CharCode oldLen, i;
 115   CharCode code1, code2;
 116   Unicode u;
 117   char uHex[5];
 118   int j;
 119   GString *name;
 120   FILE *f;
 121
 122   nDigits = nBits / 4;
 123   pst = new PSTokenizer(getCharFunc, data);
 124   pst->getToken(tok1, sizeof(tok1), &n1);
 125   while (pst->getToken(tok2, sizeof(tok2), &n2)) {
 126     if (!strcmp(tok2, "usecmap")) {
 127       if (tok1[0] == '/') {
 128         name = new GString(tok1 + 1);
 129         if ((f = globalParams->findToUnicodeFile(name))) {
 130           parseCMap1(&getCharFromFile, f, nBits);
 131           fclose(f);
 132         } else {
 133           error(-1, "Couldn't find ToUnicode CMap file for '%s'",
 134                 name->getCString());
 135         }
 136         delete name;
 137       }
 138       pst->getToken(tok1, sizeof(tok1), &n1);
 139     } else if (!strcmp(tok2, "beginbfchar")) {
 140       while (pst->getToken(tok1, sizeof(tok1), &n1)) {
 141         if (!strcmp(tok1, "endbfchar")) {
 142           break;
 143         }
 144         if (!pst->getToken(tok2, sizeof(tok2), &n2) ||
 145             !strcmp(tok2, "endbfchar")) {
 146           error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 147           break;
 148         }
 149         if (!(n1 == 2 + nDigits && tok1[0] == '<' && tok1[n1 - 1] == '>' &&
 150               tok2[0] == '<' && tok2[n2 - 1] == '>')) {
 151           error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 152           continue;
 153         }
 154         tok1[n1 - 1] = tok2[n2 - 1] = '\0';
 155         if (sscanf(tok1 + 1, "%x", &code1) != 1) {
 156           error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 157           continue;
 158         }
 159         if (code1 >= mapLen) {
 160           oldLen = mapLen;
 161           mapLen = (code1 + 256) & ~255;
 162           map = (Unicode *)grealloc(map, mapLen * sizeof(Unicode));
 163           for (i = oldLen; i < mapLen; ++i) {
 164             map[i] = 0;
 165           }
 166         }
 167         if (n2 == 6) {
 168           if (sscanf(tok2 + 1, "%x", &u) != 1) {
 169             error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 170             continue;
 171           }
 172           map[code1] = u;
 173         } else {
 174           map[code1] = 0;
 175           if (sMapLen == sMapSize) {
 176             sMapSize += 8;
 177             sMap = (CharCodeToUnicodeString *)
 178                 grealloc(sMap, sMapSize * sizeof(CharCodeToUnicodeString));
 179           }
 180           sMap[sMapLen].c = code1;
 181           sMap[sMapLen].len = (n2 - 2) / 4;
 182           for (j = 0; j < sMap[sMapLen].len && j < maxUnicodeString; ++j) {
 183             strncpy(uHex, tok2 + 1 + j*4, 4);
 184             uHex[4] = '\0';
 185             if (sscanf(uHex, "%x", &sMap[sMapLen].u[j]) != 1) {
 186               error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 187             }
 188           }
 189           ++sMapLen;
 190         }
 191       }
 192       pst->getToken(tok1, sizeof(tok1), &n1);
 193     } else if (!strcmp(tok2, "beginbfrange")) {
 194       while (pst->getToken(tok1, sizeof(tok1), &n1)) {
 195         if (!strcmp(tok1, "endbfrange")) {
 196           break;
 197         }
 198         if (!pst->getToken(tok2, sizeof(tok2), &n2) ||
 199             !strcmp(tok2, "endbfrange") ||
 200             !pst->getToken(tok3, sizeof(tok3), &n3) ||
 201             !strcmp(tok3, "endbfrange")) {
 202           error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 203           break;
 204         }
 205         if (!(n1 == 2 + nDigits && tok1[0] == '<' && tok1[n1 - 1] == '>' &&
 206               n2 == 2 + nDigits && tok2[0] == '<' && tok2[n2 - 1] == '>' &&
 207               tok3[0] == '<' && tok3[n3 - 1] == '>')) {
 208           error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 209           continue;
 210         }
 211         tok1[n1 - 1] = tok2[n2 - 1] = tok3[n3 - 1] = '\0';
 212         if (sscanf(tok1 + 1, "%x", &code1) != 1 ||
 213             sscanf(tok2 + 1, "%x", &code2) != 1) {
 214           error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 215           continue;
 216         }
 217         if (code2 >= mapLen) {
 218           oldLen = mapLen;
 219           mapLen = (code2 + 256) & ~255;
 220           map = (Unicode *)grealloc(map, mapLen * sizeof(Unicode));
 221           for (i = oldLen; i < mapLen; ++i) {
 222             map[i] = 0;
 223           }
 224         }
 225         if (n3 == 6) {
 226           if (sscanf(tok3 + 1, "%x", &u) != 1) {
 227             error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 228             continue;
 229           }
 230           for (; code1 <= code2; ++code1) {
 231             map[code1] = u++;
 232           }
 233         } else {
 234           if (sMapLen + (int)(code2 - code1 + 1) > sMapSize) {
 235             sMapSize = (sMapSize + (code2 - code1 + 1) + 7) & ~7;
 236             sMap = (CharCodeToUnicodeString *)
 237                 grealloc(sMap, sMapSize * sizeof(CharCodeToUnicodeString));
 238           }
 239           for (i = 0; code1 <= code2; ++code1, ++i) {
 240             map[code1] = 0;
 241             sMap[sMapLen].c = code1;
 242             sMap[sMapLen].len = (n3 - 2) / 4;
 243             for (j = 0; j < sMap[sMapLen].len && j < maxUnicodeString; ++j) {
 244               strncpy(uHex, tok3 + 1 + j*4, 4);
 245               uHex[4] = '\0';
 246               if (sscanf(uHex, "%x", &sMap[sMapLen].u[j]) != 1) {
 247                 error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 248               }
 249             }
 250             sMap[sMapLen].u[sMap[sMapLen].len - 1] += i;
 251             ++sMapLen;
 252           }
 253         }
 254       }
 255       pst->getToken(tok1, sizeof(tok1), &n1);
 256     } else {
 257       strcpy(tok1, tok2);
 258     }
 259   }
 260   delete pst;
 261 }
 262
 263 CharCodeToUnicode::CharCodeToUnicode(GString *collectionA) {
 264   CharCode i;
 265
 266   collection = collectionA;
 267   mapLen = 256;
 268   map = (Unicode *)gmalloc(mapLen * sizeof(Unicode));
 269   for (i = 0; i < mapLen; ++i) {
 270     map[i] = 0;
 271   }
 272   sMap = NULL;
 273   sMapLen = sMapSize = 0;
 274   refCnt = 1;
 275 }
 276
 277 CharCodeToUnicode::CharCodeToUnicode(GString *collectionA, Unicode *mapA,
 278                                      CharCode mapLenA, GBool copyMap,
 279                                      CharCodeToUnicodeString *sMapA,
 280                                      int sMapLenA) {
 281   collection = collectionA;
 282   mapLen = mapLenA;
 283   if (copyMap) {
 284     map = (Unicode *)gmalloc(mapLen * sizeof(Unicode));
 285     memcpy(map, mapA, mapLen * sizeof(Unicode));
 286   } else {
 287     map = mapA;
 288   }
 289   sMap = sMapA;
 290   sMapLen = sMapSize = sMapLenA;
 291   refCnt = 1;
 292 }
 293
 294 CharCodeToUnicode::~CharCodeToUnicode() {
 295   if (collection) {
 296     delete collection;
 297   }
 298   gfree(map);
 299   if (sMap) {
 300     gfree(sMap);
 301   }
 302 }
 303
 304 void CharCodeToUnicode::incRefCnt() {
 305   ++refCnt;
 306 }
 307
 308 void CharCodeToUnicode::decRefCnt() {
 309   if (--refCnt == 0) {
 310     delete this;
 311   }
 312 }
 313
 314 GBool CharCodeToUnicode::match(GString *collectionA) {
 315   return collection && !collection->cmp(collectionA);
 316 }
 317
 318 int CharCodeToUnicode::mapToUnicode(CharCode c, Unicode *u, int size) {
 319   int i, j;
 320
 321   if (c >= mapLen) {
 322     return 0;
 323   }
 324   if (map[c]) {
 325     u[0] = map[c];
 326     return 1;
 327   }
 328   for (i = 0; i < sMapLen; ++i) {
 329     if (sMap[i].c == c) {
 330       for (j = 0; j < sMap[i].len && j < size; ++j) {
 331         u[j] = sMap[i].u[j];
 332       }
 333       return j;
 334     }
 335   }
 336   return 0;
 337 }
 338
 339 //------------------------------------------------------------------------
 340
 341 CIDToUnicodeCache::CIDToUnicodeCache() {
 342   int i;
 343
 344   for (i = 0; i < cidToUnicodeCacheSize; ++i) {
 345     cache[i] = NULL;
 346   }
 347 }
 348
 349 CIDToUnicodeCache::~CIDToUnicodeCache() {
 350   int i;
 351
 352   for (i = 0; i < cidToUnicodeCacheSize; ++i) {
 353     if (cache[i]) {
 354       cache[i]->decRefCnt();
 355     }
 356   }
 357 }
 358
 359 CharCodeToUnicode *CIDToUnicodeCache::getCIDToUnicode(GString *collection) {
 360   CharCodeToUnicode *ctu;
 361   int i, j;
 362
 363   if (cache[0] && cache[0]->match(collection)) {
 364     cache[0]->incRefCnt();
 365     return cache[0];
 366   }
 367   for (i = 1; i < cidToUnicodeCacheSize; ++i) {
 368     if (cache[i] && cache[i]->match(collection)) {
 369       ctu = cache[i];
 370       for (j = i; j >= 1; --j) {
 371         cache[j] = cache[j - 1];
 372       }
 373       cache[0] = ctu;
 374       ctu->incRefCnt();
 375       return ctu;
 376     }
 377   }
 378   if ((ctu = CharCodeToUnicode::parseCIDToUnicode(collection))) {
 379     if (cache[cidToUnicodeCacheSize - 1]) {
 380       cache[cidToUnicodeCacheSize - 1]->decRefCnt();
 381     }
 382     for (j = cidToUnicodeCacheSize - 1; j >= 1; --j) {
 383       cache[j] = cache[j - 1];
 384     }
 385     cache[0] = ctu;
 386     ctu->incRefCnt();
 387     return ctu;
 388   }
 389   return NULL;
 390 }