pdf/xpdf/UnicodeMap.cc

   1 //========================================================================
   2 //
   3 // UnicodeMap.cc
   4 //
   5 // Copyright 2001-2002 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 <string.h>
  17 #include "gmem.h"
  18 #include "gfile.h"
  19 #include "GString.h"
  20 #include "GList.h"
  21 #include "Error.h"
  22 #include "GlobalParams.h"
  23 #include "UnicodeMap.h"
  24
  25 //------------------------------------------------------------------------
  26
  27 #define maxExtCode 16
  28
  29 struct UnicodeMapExt {
  30   Unicode u;                    // Unicode char
  31   char code[maxExtCode];
  32   Guint nBytes;
  33 };
  34
  35 //------------------------------------------------------------------------
  36
  37 UnicodeMap *UnicodeMap::parse(GString *encodingNameA) {
  38   FILE *f;
  39   UnicodeMap *map;
  40   UnicodeMapRange *range;
  41   UnicodeMapExt *eMap;
  42   int size, eMapsSize;
  43   char buf[256];
  44   int line, nBytes, i, x;
  45   char *tok1, *tok2, *tok3;
  46
  47   if (!(f = globalParams->getUnicodeMapFile(encodingNameA))) {
  48     error(-1, "Couldn't find unicodeMap file for the '%s' encoding",
  49           encodingNameA->getCString());
  50     return NULL;
  51   }
  52
  53   map = new UnicodeMap(encodingNameA->copy());
  54
  55   size = 8;
  56   map->ranges = (UnicodeMapRange *)gmalloc(size * sizeof(UnicodeMapRange));
  57   eMapsSize = 0;
  58
  59   line = 1;
  60   while (getLine(buf, sizeof(buf), f)) {
  61     if ((tok1 = strtok(buf, " \t\r\n")) &&
  62         (tok2 = strtok(NULL, " \t\r\n"))) {
  63       if (!(tok3 = strtok(NULL, " \t\r\n"))) {
  64         tok3 = tok2;
  65         tok2 = tok1;
  66       }
  67       nBytes = strlen(tok3) / 2;
  68       if (nBytes <= 4) {
  69         if (map->len == size) {
  70           size *= 2;
  71           map->ranges = (UnicodeMapRange *)
  72             grealloc(map->ranges, size * sizeof(UnicodeMapRange));
  73         }
  74         range = &map->ranges[map->len];
  75         sscanf(tok1, "%x", &range->start);
  76         sscanf(tok2, "%x", &range->end);
  77         sscanf(tok3, "%x", &range->code);
  78         range->nBytes = nBytes;
  79         ++map->len;
  80       } else if (tok2 == tok1) {
  81         if (map->eMapsLen == eMapsSize) {
  82           eMapsSize += 16;
  83           map->eMaps = (UnicodeMapExt *)
  84             grealloc(map->eMaps, eMapsSize * sizeof(UnicodeMapExt));
  85         }
  86         eMap = &map->eMaps[map->eMapsLen];
  87         sscanf(tok1, "%x", &eMap->u);
  88         for (i = 0; i < nBytes; ++i) {
  89           sscanf(tok3 + i*2, "%2x", &x);
  90           eMap->code[i] = (char)x;
  91         }
  92         eMap->nBytes = nBytes;
  93         ++map->eMapsLen;
  94       } else {
  95         error(-1, "Bad line (%d) in unicodeMap file for the '%s' encoding",
  96               line, encodingNameA->getCString());
  97       }
  98     } else {
  99       error(-1, "Bad line (%d) in unicodeMap file for the '%s' encoding",
 100             line, encodingNameA->getCString());
 101     }
 102     ++line;
 103   }
 104
 105   fclose(f);
 106
 107   return map;
 108 }
 109
 110 UnicodeMap::UnicodeMap(GString *encodingNameA) {
 111   encodingName = encodingNameA;
 112   unicodeOut = gFalse;
 113   kind = unicodeMapUser;
 114   ranges = NULL;
 115   len = 0;
 116   eMaps = NULL;
 117   eMapsLen = 0;
 118   refCnt = 1;
 119 }
 120
 121 UnicodeMap::UnicodeMap(char *encodingNameA, GBool unicodeOutA,
 122                        UnicodeMapRange *rangesA, int lenA) {
 123   encodingName = new GString(encodingNameA);
 124   unicodeOut = unicodeOutA;
 125   kind = unicodeMapResident;
 126   ranges = rangesA;
 127   len = lenA;
 128   eMaps = NULL;
 129   eMapsLen = 0;
 130   refCnt = 1;
 131 }
 132
 133 UnicodeMap::UnicodeMap(char *encodingNameA, GBool unicodeOutA,
 134                        UnicodeMapFunc funcA) {
 135   encodingName = new GString(encodingNameA);
 136   unicodeOut = unicodeOutA;
 137   kind = unicodeMapFunc;
 138   func = funcA;
 139   eMaps = NULL;
 140   eMapsLen = 0;
 141   refCnt = 1;
 142 }
 143
 144 UnicodeMap::~UnicodeMap() {
 145   delete encodingName;
 146   if (kind == unicodeMapUser && ranges) {
 147     gfree(ranges);
 148   }
 149   if (eMaps) {
 150     gfree(eMaps);
 151   }
 152 }
 153
 154 void UnicodeMap::incRefCnt() {
 155   ++refCnt;
 156 }
 157
 158 void UnicodeMap::decRefCnt() {
 159   if (--refCnt == 0) {
 160     delete this;
 161   }
 162 }
 163
 164 GBool UnicodeMap::match(GString *encodingNameA) {
 165   return !encodingName->cmp(encodingNameA);
 166 }
 167
 168 int UnicodeMap::mapUnicode(Unicode u, char *buf, int bufSize) {
 169   int a, b, m, n, i, j;
 170   Guint code;
 171
 172   if (kind == unicodeMapFunc) {
 173     return (*func)(u, buf, bufSize);
 174   }
 175
 176   a = 0;
 177   b = len;
 178   if (u < ranges[a].start) {
 179     return 0;
 180   }
 181   // invariant: ranges[a].start <= u < ranges[b].start
 182   while (b - a > 1) {
 183     m = (a + b) / 2;
 184     if (u >= ranges[m].start) {
 185       a = m;
 186     } else if (u < ranges[m].start) {
 187       b = m;
 188     }
 189   }
 190   if (u <= ranges[a].end) {
 191     n = ranges[a].nBytes;
 192     if (n > bufSize) {
 193       return 0;
 194     }
 195     code = ranges[a].code + (u - ranges[a].start);
 196     for (i = n - 1; i >= 0; --i) {
 197       buf[i] = (char)(code & 0xff);
 198       code >>= 8;
 199     }
 200     return n;
 201   }
 202
 203   for (i = 0; i < eMapsLen; ++i) {
 204     if (eMaps[i].u == u) {
 205       n = eMaps[i].nBytes;
 206       for (j = 0; j < n; ++j) {
 207         buf[j] = eMaps[i].code[j];
 208       }
 209       return n;
 210     }
 211   }
 212
 213   return 0;
 214 }
 215
 216 //------------------------------------------------------------------------
 217
 218 UnicodeMapCache::UnicodeMapCache() {
 219   int i;
 220
 221   for (i = 0; i < unicodeMapCacheSize; ++i) {
 222     cache[i] = NULL;
 223   }
 224 }
 225
 226 UnicodeMapCache::~UnicodeMapCache() {
 227   int i;
 228
 229   for (i = 0; i < unicodeMapCacheSize; ++i) {
 230     if (cache[i]) {
 231       cache[i]->decRefCnt();
 232     }
 233   }
 234 }
 235
 236 UnicodeMap *UnicodeMapCache::getUnicodeMap(GString *encodingName) {
 237   UnicodeMap *map;
 238   int i, j;
 239
 240   if (cache[0] && cache[0]->match(encodingName)) {
 241     cache[0]->incRefCnt();
 242     return cache[0];
 243   }
 244   for (i = 1; i < unicodeMapCacheSize; ++i) {
 245     if (cache[i] && cache[i]->match(encodingName)) {
 246       map = cache[i];
 247       for (j = i; j >= 1; --j) {
 248         cache[j] = cache[j - 1];
 249       }
 250       cache[0] = map;
 251       map->incRefCnt();
 252       return map;
 253     }
 254   }
 255   if ((map = UnicodeMap::parse(encodingName))) {
 256     if (cache[unicodeMapCacheSize - 1]) {
 257       cache[unicodeMapCacheSize - 1]->decRefCnt();
 258     }
 259     for (j = unicodeMapCacheSize - 1; j >= 1; --j) {
 260       cache[j] = cache[j - 1];
 261     }
 262     cache[0] = map;
 263     map->incRefCnt();
 264     return map;
 265   }
 266   return NULL;
 267 }