pdf2swf/xpdf/CMap.cc

   1 //========================================================================
   2 //
   3 // CMap.cc
   4 //
   5 // Copyright 2001-2003 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #include <aconf.h>
  10
  11 #ifdef USE_GCC_PRAGMAS
  12 #pragma implementation
  13 #endif
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include "gmem.h"
  20 #include "gfile.h"
  21 #include "GString.h"
  22 #include "Error.h"
  23 #include "GlobalParams.h"
  24 #include "PSTokenizer.h"
  25 #include "CMap.h"
  26
  27 //------------------------------------------------------------------------
  28
  29 struct CMapVectorEntry {
  30   GBool isVector;
  31   union {
  32     CMapVectorEntry *vector;
  33     CID cid;
  34   };
  35 };
  36
  37 //------------------------------------------------------------------------
  38
  39 static int getCharFromFile(void *data) {
  40   return fgetc((FILE *)data);
  41 }
  42
  43 //------------------------------------------------------------------------
  44
  45 CMap *CMap::parse(CMapCache *cache, GString *collectionA,
  46                   GString *cMapNameA) {
  47   FILE *f;
  48   CMap *cmap;
  49   PSTokenizer *pst;
  50   char tok1[256], tok2[256], tok3[256];
  51   int n1, n2, n3;
  52   Guint start, end;
  53
  54   if (!(f = globalParams->findCMapFile(collectionA, cMapNameA))) {
  55
  56     // Check for an identity CMap.
  57     if (!cMapNameA->cmp("Identity") || !cMapNameA->cmp("Identity-H")) {
  58       return new CMap(collectionA->copy(), cMapNameA->copy(), 0);
  59     }
  60     if (!cMapNameA->cmp("Identity-V")) {
  61       return new CMap(collectionA->copy(), cMapNameA->copy(), 1);
  62     }
  63
  64     error(-1, "Couldn't find '%s' CMap file for '%s' collection",
  65           cMapNameA->getCString(), collectionA->getCString());
  66     return NULL;
  67   }
  68
  69   cmap = new CMap(collectionA->copy(), cMapNameA->copy());
  70
  71   pst = new PSTokenizer(&getCharFromFile, f);
  72   pst->getToken(tok1, sizeof(tok1), &n1);
  73   while (pst->getToken(tok2, sizeof(tok2), &n2)) {
  74     if (!strcmp(tok2, "usecmap")) {
  75       if (tok1[0] == '/') {
  76         cmap->useCMap(cache, tok1 + 1);
  77       }
  78       pst->getToken(tok1, sizeof(tok1), &n1);
  79     } else if (!strcmp(tok1, "/WMode")) {
  80       cmap->wMode = atoi(tok2);
  81       pst->getToken(tok1, sizeof(tok1), &n1);
  82     } else if (!strcmp(tok2, "begincodespacerange")) {
  83       while (pst->getToken(tok1, sizeof(tok1), &n1)) {
  84         if (!strcmp(tok1, "endcodespacerange")) {
  85           break;
  86         }
  87         if (!pst->getToken(tok2, sizeof(tok2), &n2) ||
  88             !strcmp(tok2, "endcodespacerange")) {
  89           error(-1, "Illegal entry in codespacerange block in CMap");
  90           break;
  91         }
  92         if (tok1[0] == '<' && tok2[0] == '<' &&
  93             n1 == n2 && n1 >= 4 && (n1 & 1) == 0) {
  94           tok1[n1 - 1] = tok2[n1 - 1] = '\0';
  95           sscanf(tok1 + 1, "%x", &start);
  96           sscanf(tok2 + 1, "%x", &end);
  97           n1 = (n1 - 2) / 2;
  98           cmap->addCodeSpace(cmap->vector, start, end, n1);
  99         }
 100       }
 101       pst->getToken(tok1, sizeof(tok1), &n1);
 102     } else if (!strcmp(tok2, "begincidrange")) {
 103       while (pst->getToken(tok1, sizeof(tok1), &n1)) {
 104         if (!strcmp(tok1, "endcidrange")) {
 105           break;
 106         }
 107         if (!pst->getToken(tok2, sizeof(tok2), &n2) ||
 108             !strcmp(tok2, "endcidrange") ||
 109             !pst->getToken(tok3, sizeof(tok3), &n3) ||
 110             !strcmp(tok3, "endcidrange")) {
 111           error(-1, "Illegal entry in cidrange block in CMap");
 112           break;
 113         }
 114         if (tok1[0] == '<' && tok2[0] == '<' &&
 115             n1 == n2 && n1 >= 4 && (n1 & 1) == 0) {
 116           tok1[n1 - 1] = tok2[n1 - 1] = '\0';
 117           sscanf(tok1 + 1, "%x", &start);
 118           sscanf(tok2 + 1, "%x", &end);
 119           n1 = (n1 - 2) / 2;
 120           cmap->addCIDs(start, end, n1, (CID)atoi(tok3));
 121         }
 122       }
 123       pst->getToken(tok1, sizeof(tok1), &n1);
 124     } else {
 125       strcpy(tok1, tok2);
 126     }
 127   }
 128   delete pst;
 129
 130   fclose(f);
 131
 132   return cmap;
 133 }
 134
 135 CMap::CMap(GString *collectionA, GString *cMapNameA) {
 136   int i;
 137
 138   collection = collectionA;
 139   cMapName = cMapNameA;
 140   wMode = 0;
 141   vector = (CMapVectorEntry *)gmalloc(256 * sizeof(CMapVectorEntry));
 142   for (i = 0; i < 256; ++i) {
 143     vector[i].isVector = gFalse;
 144     vector[i].cid = 0;
 145   }
 146   refCnt = 1;
 147 #if MULTITHREADED
 148   gInitMutex(&mutex);
 149 #endif
 150 }
 151
 152 CMap::CMap(GString *collectionA, GString *cMapNameA, int wModeA) {
 153   collection = collectionA;
 154   cMapName = cMapNameA;
 155   wMode = wModeA;
 156   vector = NULL;
 157   refCnt = 1;
 158 #if MULTITHREADED
 159   gInitMutex(&mutex);
 160 #endif
 161 }
 162
 163 void CMap::useCMap(CMapCache *cache, char *useName) {
 164   GString *useNameStr;
 165   CMap *subCMap;
 166
 167   useNameStr = new GString(useName);
 168   subCMap = cache->getCMap(collection, useNameStr);
 169   delete useNameStr;
 170   if (!subCMap) {
 171     return;
 172   }
 173   copyVector(vector, subCMap->vector);
 174   subCMap->decRefCnt();
 175 }
 176
 177 void CMap::copyVector(CMapVectorEntry *dest, CMapVectorEntry *src) {
 178   int i, j;
 179
 180   for (i = 0; i < 256; ++i) {
 181     if (src[i].isVector) {
 182       if (!dest[i].isVector) {
 183         dest[i].isVector = gTrue;
 184         dest[i].vector =
 185           (CMapVectorEntry *)gmalloc(256 * sizeof(CMapVectorEntry));
 186         for (j = 0; j < 256; ++j) {
 187           dest[i].vector[j].isVector = gFalse;
 188           dest[i].vector[j].cid = 0;
 189         }
 190       }
 191       copyVector(dest[i].vector, src[i].vector);
 192     } else {
 193       if (dest[i].isVector) {
 194         error(-1, "Collision in usecmap");
 195       } else {
 196         dest[i].cid = src[i].cid;
 197       }
 198     }
 199   }
 200 }
 201
 202 void CMap::addCodeSpace(CMapVectorEntry *vec, Guint start, Guint end,
 203                         Guint nBytes) {
 204   Guint start2, end2;
 205   int startByte, endByte, i, j;
 206
 207   if (nBytes > 1) {
 208     startByte = (start >> (8 * (nBytes - 1))) & 0xff;
 209     endByte = (end >> (8 * (nBytes - 1))) & 0xff;
 210     start2 = start & ((1 << (8 * (nBytes - 1))) - 1);
 211     end2 = end & ((1 << (8 * (nBytes - 1))) - 1);
 212     for (i = startByte; i <= endByte; ++i) {
 213       if (!vec[i].isVector) {
 214         vec[i].isVector = gTrue;
 215         vec[i].vector =
 216           (CMapVectorEntry *)gmalloc(256 * sizeof(CMapVectorEntry));
 217         for (j = 0; j < 256; ++j) {
 218           vec[i].vector[j].isVector = gFalse;
 219           vec[i].vector[j].cid = 0;
 220         }
 221       }
 222       addCodeSpace(vec[i].vector, start2, end2, nBytes - 1);
 223     }
 224   }
 225 }
 226
 227 void CMap::addCIDs(Guint start, Guint end, Guint nBytes, CID firstCID) {
 228   CMapVectorEntry *vec;
 229   CID cid;
 230   int byte;
 231   Guint i;
 232
 233   vec = vector;
 234   for (i = nBytes - 1; i >= 1; --i) {
 235     byte = (start >> (8 * i)) & 0xff;
 236     if (!vec[byte].isVector) {
 237       error(-1, "Invalid CID (%*x - %*x) in CMap",
 238             2*nBytes, start, 2*nBytes, end);
 239       return;
 240     }
 241     vec = vec[byte].vector;
 242   }
 243   cid = firstCID;
 244   for (byte = (int)(start & 0xff); byte <= (int)(end & 0xff); ++byte) {
 245     if (vec[byte].isVector) {
 246       error(-1, "Invalid CID (%*x - %*x) in CMap",
 247             2*nBytes, start, 2*nBytes, end);
 248     } else {
 249       vec[byte].cid = cid;
 250     }
 251     ++cid;
 252   }
 253 }
 254
 255 CMap::~CMap() {
 256   delete collection;
 257   delete cMapName;
 258   if (vector) {
 259     freeCMapVector(vector);
 260   }
 261 #if MULTITHREADED
 262   gDestroyMutex(&mutex);
 263 #endif
 264 }
 265
 266 void CMap::freeCMapVector(CMapVectorEntry *vec) {
 267   int i;
 268
 269   for (i = 0; i < 256; ++i) {
 270     if (vec[i].isVector) {
 271       freeCMapVector(vec[i].vector);
 272     }
 273   }
 274   gfree(vec);
 275 }
 276
 277 void CMap::incRefCnt() {
 278 #if MULTITHREADED
 279   gLockMutex(&mutex);
 280 #endif
 281   ++refCnt;
 282 #if MULTITHREADED
 283   gUnlockMutex(&mutex);
 284 #endif
 285 }
 286
 287 void CMap::decRefCnt() {
 288   GBool done;
 289
 290 #if MULTITHREADED
 291   gLockMutex(&mutex);
 292 #endif
 293   done = --refCnt == 0;
 294 #if MULTITHREADED
 295   gUnlockMutex(&mutex);
 296 #endif
 297   if (done) {
 298     delete this;
 299   }
 300 }
 301
 302 GBool CMap::match(GString *collectionA, GString *cMapNameA) {
 303   return !collection->cmp(collectionA) && !cMapName->cmp(cMapNameA);
 304 }
 305
 306 CID CMap::getCID(char *s, int len, int *nUsed) {
 307   CMapVectorEntry *vec;
 308   int n, i;
 309
 310   if (!(vec = vector)) {
 311     // identity CMap
 312     *nUsed = 2;
 313     if (len < 2) {
 314       return 0;
 315     }
 316     return ((s[0] & 0xff) << 8) + (s[1] & 0xff);
 317   }
 318   n = 0;
 319   while (1) {
 320     if (n >= len) {
 321       *nUsed = n;
 322       return 0;
 323     }
 324     i = s[n++] & 0xff;
 325     if (!vec[i].isVector) {
 326       *nUsed = n;
 327       return vec[i].cid;
 328     }
 329     vec = vec[i].vector;
 330   }
 331 }
 332
 333 //------------------------------------------------------------------------
 334
 335 CMapCache::CMapCache() {
 336   int i;
 337
 338   for (i = 0; i < cMapCacheSize; ++i) {
 339     cache[i] = NULL;
 340   }
 341 }
 342
 343 CMapCache::~CMapCache() {
 344   int i;
 345
 346   for (i = 0; i < cMapCacheSize; ++i) {
 347     if (cache[i]) {
 348       cache[i]->decRefCnt();
 349     }
 350   }
 351 }
 352
 353 CMap *CMapCache::getCMap(GString *collection, GString *cMapName) {
 354   CMap *cmap;
 355   int i, j;
 356
 357   if (cache[0] && cache[0]->match(collection, cMapName)) {
 358     cache[0]->incRefCnt();
 359     return cache[0];
 360   }
 361   for (i = 1; i < cMapCacheSize; ++i) {
 362     if (cache[i] && cache[i]->match(collection, cMapName)) {
 363       cmap = cache[i];
 364       for (j = i; j >= 1; --j) {
 365         cache[j] = cache[j - 1];
 366       }
 367       cache[0] = cmap;
 368       cmap->incRefCnt();
 369       return cmap;
 370     }
 371   }
 372   if ((cmap = CMap::parse(this, collection, cMapName))) {
 373     if (cache[cMapCacheSize - 1]) {
 374       cache[cMapCacheSize - 1]->decRefCnt();
 375     }
 376     for (j = cMapCacheSize - 1; j >= 1; --j) {
 377       cache[j] = cache[j - 1];
 378     }
 379     cache[0] = cmap;
 380     cmap->incRefCnt();
 381     return cmap;
 382   }
 383   return NULL;
 384 }