core/src/fpdfapi/fpdf_cmaps/fpdf_cmaps.cpp

   1 // Copyright 2014 PDFium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
   6
   7 #include "../../../include/fpdfapi/fpdf_resource.h"
   8 #include "../../../include/fpdfapi/fpdf_module.h"
   9 #include "../fpdf_font/font_int.h"
  10 #include "cmap_int.h"
  11 void FPDFAPI_FindEmbeddedCMap(const char* name,
  12                               int charset,
  13                               int coding,
  14                               const FXCMAP_CMap*& pMap) {
  15   pMap = NULL;
  16   CPDF_FontGlobals* pFontGlobals =
  17       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
  18   const FXCMAP_CMap* pCMaps =
  19       pFontGlobals->m_EmbeddedCharsets[charset].m_pMapList;
  20   int nCMaps = pFontGlobals->m_EmbeddedCharsets[charset].m_Count;
  21   for (int i = 0; i < nCMaps; i++) {
  22     if (FXSYS_strcmp(name, pCMaps[i].m_Name)) {
  23       continue;
  24     }
  25     pMap = &pCMaps[i];
  26     break;
  27   }
  28 }
  29 extern "C" {
  30 static int compareWord(const void* p1, const void* p2) {
  31   return (*(FX_WORD*)p1) - (*(FX_WORD*)p2);
  32 }
  33 };
  34 extern "C" {
  35 static int compareWordRange(const void* key, const void* element) {
  36   if (*(FX_WORD*)key < *(FX_WORD*)element) {
  37     return -1;
  38   }
  39   if (*(FX_WORD*)key > ((FX_WORD*)element)[1]) {
  40     return 1;
  41   }
  42   return 0;
  43 }
  44 };
  45 extern "C" {
  46 static int compareDWordRange(const void* p1, const void* p2) {
  47   FX_DWORD key = *(FX_DWORD*)p1;
  48   FX_WORD hiword = (FX_WORD)(key >> 16);
  49   FX_WORD* element = (FX_WORD*)p2;
  50   if (hiword < element[0]) {
  51     return -1;
  52   }
  53   if (hiword > element[0]) {
  54     return 1;
  55   }
  56   FX_WORD loword = (FX_WORD)key;
  57   if (loword < element[1]) {
  58     return -1;
  59   }
  60   if (loword > element[2]) {
  61     return 1;
  62   }
  63   return 0;
  64 }
  65 };
  66 extern "C" {
  67 static int compareDWordSingle(const void* p1, const void* p2) {
  68   FX_DWORD key = *(FX_DWORD*)p1;
  69   FX_DWORD value = ((*(FX_WORD*)p2) << 16) | ((FX_WORD*)p2)[1];
  70   if (key < value) {
  71     return -1;
  72   }
  73   if (key > value) {
  74     return 1;
  75   }
  76   return 0;
  77 }
  78 };
  79 FX_WORD FPDFAPI_CIDFromCharCode(const FXCMAP_CMap* pMap, FX_DWORD charcode) {
  80   if (charcode >> 16) {
  81     while (1) {
  82       if (pMap->m_DWordMapType == FXCMAP_CMap::Range) {
  83         FX_WORD* found =
  84             (FX_WORD*)FXSYS_bsearch(&charcode, pMap->m_pDWordMap,
  85                                     pMap->m_DWordCount, 8, compareDWordRange);
  86         if (found) {
  87           return found[3] + (FX_WORD)charcode - found[1];
  88         }
  89       } else if (pMap->m_DWordMapType == FXCMAP_CMap::Single) {
  90         FX_WORD* found =
  91             (FX_WORD*)FXSYS_bsearch(&charcode, pMap->m_pDWordMap,
  92                                     pMap->m_DWordCount, 6, compareDWordSingle);
  93         if (found) {
  94           return found[2];
  95         }
  96       }
  97       if (pMap->m_UseOffset == 0) {
  98         return 0;
  99       }
 100       pMap = pMap + pMap->m_UseOffset;
 101     }
 102     return 0;
 103   }
 104   FX_WORD code = (FX_WORD)charcode;
 105   while (1) {
 106     if (pMap->m_pWordMap == NULL) {
 107       return 0;
 108     }
 109     if (pMap->m_WordMapType == FXCMAP_CMap::Single) {
 110       FX_WORD* found = (FX_WORD*)FXSYS_bsearch(
 111           &code, pMap->m_pWordMap, pMap->m_WordCount, 4, compareWord);
 112       if (found) {
 113         return found[1];
 114       }
 115     } else if (pMap->m_WordMapType == FXCMAP_CMap::Range) {
 116       FX_WORD* found = (FX_WORD*)FXSYS_bsearch(
 117           &code, pMap->m_pWordMap, pMap->m_WordCount, 6, compareWordRange);
 118       if (found) {
 119         return found[2] + code - found[0];
 120       }
 121     }
 122     if (pMap->m_UseOffset == 0) {
 123       return 0;
 124     }
 125     pMap = pMap + pMap->m_UseOffset;
 126   }
 127   return 0;
 128 }
 129 FX_DWORD FPDFAPI_CharCodeFromCID(const FXCMAP_CMap* pMap, FX_WORD cid) {
 130   while (1) {
 131     if (pMap->m_WordMapType == FXCMAP_CMap::Single) {
 132       const FX_WORD* pCur = pMap->m_pWordMap;
 133       const FX_WORD* pEnd = pMap->m_pWordMap + pMap->m_WordCount * 2;
 134       while (pCur < pEnd) {
 135         if (pCur[1] == cid) {
 136           return pCur[0];
 137         }
 138         pCur += 2;
 139       }
 140     } else if (pMap->m_WordMapType == FXCMAP_CMap::Range) {
 141       const FX_WORD* pCur = pMap->m_pWordMap;
 142       const FX_WORD* pEnd = pMap->m_pWordMap + pMap->m_WordCount * 3;
 143       while (pCur < pEnd) {
 144         if (cid >= pCur[2] && cid <= pCur[2] + pCur[1] - pCur[0]) {
 145           return pCur[0] + cid - pCur[2];
 146         }
 147         pCur += 3;
 148       }
 149     }
 150     if (pMap->m_UseOffset == 0) {
 151       return 0;
 152     }
 153     pMap = pMap + pMap->m_UseOffset;
 154   }
 155   while (1) {
 156     if (pMap->m_DWordMapType == FXCMAP_CMap::Range) {
 157       const FX_WORD* pCur = pMap->m_pDWordMap;
 158       const FX_WORD* pEnd = pMap->m_pDWordMap + pMap->m_DWordCount * 4;
 159       while (pCur < pEnd) {
 160         if (cid >= pCur[3] && cid <= pCur[3] + pCur[2] - pCur[1]) {
 161           return (((FX_DWORD)pCur[0] << 16) | pCur[1]) + cid - pCur[3];
 162         }
 163         pCur += 4;
 164       }
 165     } else if (pMap->m_DWordMapType == FXCMAP_CMap::Single) {
 166       const FX_WORD* pCur = pMap->m_pDWordMap;
 167       const FX_WORD* pEnd = pMap->m_pDWordMap + pMap->m_DWordCount * 3;
 168       while (pCur < pEnd) {
 169         if (pCur[2] == cid) {
 170           return ((FX_DWORD)pCur[0] << 16) | pCur[1];
 171         }
 172         pCur += 3;
 173       }
 174     }
 175     if (pMap->m_UseOffset == 0) {
 176       return 0;
 177     }
 178     pMap = pMap + pMap->m_UseOffset;
 179   }
 180   return 0;
 181 }
 182 void FPDFAPI_LoadCID2UnicodeMap(int charset,
 183                                 const FX_WORD*& pMap,
 184                                 FX_DWORD& count) {
 185   CPDF_FontGlobals* pFontGlobals =
 186       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
 187   pMap = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
 188   count = pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count;
 189 }