Back to index

texmacs  1.0.7.15
Classes | Defines | Functions | Variables
cid.c File Reference
#include <string.h>
#include "system.h"
#include "mem.h"
#include "error.h"
#include "dpxutil.h"
#include "pdfobj.h"
#include "cidtype0.h"
#include "cidtype2.h"
#include "cid_p.h"
#include "cid.h"
#include "pdfparse.h"
#include "cid_basefont.h"

Go to the source code of this file.

Classes

struct  FontCache

Defines

#define CIDFONT_DEBUG   3
#define CIDFONT_DEBUG_STR   "CIDFont"
#define PDF_CID_SUPPORT_MIN   2
#define PDF_CID_SUPPORT_MAX   6
#define UCS_CC   0
#define ACC_START   1
#define ACC_END   4
#define CACHE_ALLOC_SIZE   16u
#define CHECK_ID(n)

Functions

static void release_opt (cid_opt *opt)
static CIDSysInfoget_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt)
void CIDFont_set_verbose (void)
CIDFontCIDFont_new (void)
void CIDFont_flush (CIDFont *font)
void CIDFont_release (CIDFont *font)
char * CIDFont_get_fontname (CIDFont *font)
char * CIDFont_get_ident (CIDFont *font)
int CIDFont_get_opt_index (CIDFont *font)
int CIDFont_get_subtype (CIDFont *font)
int CIDFont_get_embedding (CIDFont *font)
CIDSysInfoCIDFont_get_CIDSysInfo (CIDFont *font)
int CIDFont_get_parent_id (CIDFont *font, int wmode)
pdf_objCIDFont_get_resource (CIDFont *font)
void CIDFont_attach_parent (CIDFont *font, int parent_id, int wmode)
int CIDFont_is_ACCFont (CIDFont *font)
int CIDFont_is_UCSFont (CIDFont *font)
int CIDFont_get_flag (CIDFont *font, int mask)
static void CIDFont_dofont (CIDFont *font)
int CIDFont_is_BaseFont (CIDFont *font)
static int CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_opt *opt)
void CIDFont_cache_init (void)
CIDFontCIDFont_cache_get (int font_id)
int CIDFont_cache_find (const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt)
void CIDFont_cache_close (void)
void CIDFont_set_flags (long flags)

Variables

struct {
const char * registry
const char * ordering
int supplement [16]
CIDFont_stdcc_def []
CIDSysInfo CSI_IDENTITY
CIDSysInfo CSI_UNICODE
struct {
const char * name
int index
CIDFont_stdcc_alias []
static int __verbose = 0
static long cidoptflags = 0
static struct FontCache__cache = NULL

Class Documentation

struct FontCache

Definition at line 514 of file cid.c.

Collaboration diagram for FontCache:
Class Members
CIDFont ** fonts
int max
int num

Define Documentation

#define ACC_END   4

Definition at line 77 of file cid.c.

#define ACC_START   1

Definition at line 76 of file cid.c.

#define CACHE_ALLOC_SIZE   16u

Definition at line 512 of file cid.c.

#define CHECK_ID (   n)
Value:
do {\
                        if (! __cache)\
                           ERROR("%s: CIDFont cache not initialized.", CIDFONT_DEBUG_STR);\
                        if ((n) < 0 || (n) >= __cache->num)\
                           ERROR("%s: Invalid ID %d", CIDFONT_DEBUG_STR, (n));\
                    } while (0)

Definition at line 522 of file cid.c.

#define CIDFONT_DEBUG   3

Definition at line 47 of file cid.c.

#define CIDFONT_DEBUG_STR   "CIDFont"

Definition at line 48 of file cid.c.

#define PDF_CID_SUPPORT_MAX   6

Definition at line 51 of file cid.c.

#define PDF_CID_SUPPORT_MIN   2

Definition at line 50 of file cid.c.

#define UCS_CC   0

Definition at line 75 of file cid.c.


Function Documentation

void CIDFont_attach_parent ( CIDFont font,
int  parent_id,
int  wmode 
)

Definition at line 287 of file cid.c.

{
  ASSERT(font);

  if (wmode < 0 || wmode > 1)
    ERROR("%s: Invalid wmode value.", CIDFONT_DEBUG_STR);

  if (font->parent[wmode] >= 0)
    WARN("%s: CIDFont already have a parent Type1 font.", CIDFONT_DEBUG_STR);

  font->parent[wmode] = parent_id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int CIDFont_base_open ( CIDFont font,
const char *  name,
CIDSysInfo cmap_csi,
cid_opt opt 
) [static]

Definition at line 390 of file cid.c.

{
  pdf_obj *fontdict, *descriptor;
  char    *fontname = NULL;
  int      idx;

  ASSERT(font);

  for (idx = 0; cid_basefont[idx].fontname != NULL; idx++) {
    if (!strcmp(name, cid_basefont[idx].fontname) ||
        (strlen(name) == strlen(cid_basefont[idx].fontname) - strlen("-Acro") &&
         !strncmp(name, cid_basefont[idx].fontname,
                  strlen(cid_basefont[idx].fontname)-strlen("-Acro")))
        )
      break;
  }

  if (cid_basefont[idx].fontname == NULL)
    return -1;

  fontname = NEW(strlen(name)+12, char);
  memset(fontname, 0, strlen(name)+12);
  strcpy(fontname, name);

  switch (opt->style) {
  case FONT_STYLE_BOLD:
    strcat(fontname, ",Bold");
    break;
  case FONT_STYLE_ITALIC:
    strcat(fontname, ",Italic");
    break;
  case FONT_STYLE_BOLDITALIC:
    strcat(fontname, ",BoldItalic");
    break;
  }
  {
    const char *start;
    const char *end;

    start = cid_basefont[idx].fontdict;
    end   = start + strlen(start);
    fontdict   = parse_pdf_dict((char **)&start, (char *)end, NULL);
    start = cid_basefont[idx].descriptor;
    end   = start + strlen(start);
    descriptor = parse_pdf_dict((char **)&start, (char *)end, NULL);

    ASSERT(fontdict && descriptor);
  }

  font->fontname = fontname;
  font->flags   |= FONT_FLAG_BASEFONT;
  {
    char    *registry, *ordering;
    int      supplement;
    pdf_obj *tmp;

    tmp = pdf_lookup_dict(fontdict, "CIDSystemInfo");

    ASSERT( tmp && pdf_obj_typeof(tmp) == PDF_DICT );

    registry   = pdf_string_value(pdf_lookup_dict(tmp, "Registry"));
    ordering   = pdf_string_value(pdf_lookup_dict(tmp, "Ordering"));
    supplement = pdf_number_value(pdf_lookup_dict(tmp, "Supplement"));
    if (cmap_csi) { /* NULL for accept any */
      if (strcmp(registry, cmap_csi->registry) ||
          strcmp(ordering, cmap_csi->ordering))
        ERROR("Inconsistent CMap used for CID-keyed font %s.",
              cid_basefont[idx].fontname);
      else if (supplement < cmap_csi->supplement) {
        WARN("CMap has higher supplement number than CIDFont: %s", fontname);
        WARN("Some chracters may not be displayed or printed.");
      }
    }
    font->csi = NEW(1, CIDSysInfo);
    font->csi->registry = NEW(strlen(registry)+1, char);
    font->csi->ordering = NEW(strlen(ordering)+1, char);
    strcpy(font->csi->registry, registry);
    strcpy(font->csi->ordering, ordering);
    font->csi->supplement = supplement;
  }

  {
    pdf_obj *tmp;
    char    *type;

    tmp  = pdf_lookup_dict(fontdict, "Subtype");
    ASSERT( tmp != NULL && pdf_obj_typeof(tmp) == PDF_NAME );

    type = pdf_name_value(tmp);
    if (!strcmp(type, "CIDFontType0"))
      font->subtype = CIDFONT_TYPE0;
    else if (!strcmp(type, "CIDFontType2"))
      font->subtype = CIDFONT_TYPE2;
    else {
      ERROR("Unknown CIDFontType \"%s\"", type);
    }
  }

  if (cidoptflags & CIDFONT_FORCE_FIXEDPITCH) {
    if (pdf_lookup_dict(fontdict, "W")) {
       pdf_remove_dict(fontdict, "W");
    }
    if (pdf_lookup_dict(fontdict, "W2")) {
       pdf_remove_dict(fontdict, "W2");
    }
  }

  pdf_add_dict(fontdict,   pdf_new_name("Type"),     pdf_new_name("Font"));
  pdf_add_dict(fontdict,   pdf_new_name("BaseFont"), pdf_new_name(fontname));
  pdf_add_dict(descriptor, pdf_new_name("Type"),     pdf_new_name("FontDescriptor"));
  pdf_add_dict(descriptor, pdf_new_name("FontName"), pdf_new_name(fontname));

  font->fontdict   = fontdict;
  font->descriptor = descriptor;

  opt->embed = 0;

  return  0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CIDFont_cache_close ( void  )

Definition at line 658 of file cid.c.

{
  int  font_id;

  if (__cache) {
    for (font_id = 0;
        font_id < __cache->num; font_id++) {
      CIDFont *font;

      font = __cache->fonts[font_id];

      if (__verbose)
       MESG("(CID");

      CIDFont_dofont (font);
      CIDFont_flush  (font);
      CIDFont_release(font);

      RELEASE(font);

      if (__verbose)
       MESG(")");
    }
    RELEASE(__cache->fonts);
    RELEASE(__cache);
    __cache = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CIDFont_cache_find ( const char *  map_name,
CIDSysInfo cmap_csi,
fontmap_opt fmap_opt 
)

Definition at line 553 of file cid.c.

{
  int      font_id = -1;
  CIDFont *font    = NULL;
  cid_opt *opt     = NULL;

  if (!__cache)
    CIDFont_cache_init();

  opt  = NEW(1, cid_opt);
  opt->style = fmap_opt->style;
  opt->index = fmap_opt->index;
  opt->embed = (fmap_opt->flags & FONTMAP_OPT_NOEMBED) ? 0 : 1;
  opt->name  = NULL;
  opt->csi   = get_cidsysinfo(map_name, fmap_opt);
  opt->stemv = fmap_opt->stemv;

  if (!opt->csi && cmap_csi) {
    /*
     * No CIDSystemInfo supplied explicitly. Copy from CMap's one if available.
     * It is not neccesary for CID-keyed fonts. But TrueType requires them.
     */
    opt->csi = NEW(1, CIDSysInfo);
    opt->csi->registry   = NEW(strlen(cmap_csi->registry)+1, char);
    strcpy(opt->csi->registry, cmap_csi->registry);
    opt->csi->ordering   = NEW(strlen(cmap_csi->ordering)+1, char);
    strcpy(opt->csi->ordering, cmap_csi->ordering);
    opt->csi->supplement = cmap_csi->supplement;
  }
  /*
   * Here, we do not compare font->ident and map_name because of
   * implicit CIDSystemInfo supplied by CMap for TrueType.
   */
  for (font_id = 0; font_id < __cache->num; font_id++) {
    font = __cache->fonts[font_id];
    if (!strcmp(font->name, map_name) &&
       font->options->style == opt->style &&
       font->options->index == opt->index) {
      if (font->options->embed == opt->embed) {
       /*
        * Case 1: CSI not available (Identity CMap)
        *         Font is TrueType --> continue
        *         Font is CIDFont  --> break
        * Case 2: CSI matched      --> break
        */
       if (!opt->csi) {
         if (font->subtype == CIDFONT_TYPE2)
           continue;
         else
           break;
       } else if (!strcmp(font->csi->registry, opt->csi->registry) &&
                 !strcmp(font->csi->ordering, opt->csi->ordering)) {
         if (font->subtype == CIDFONT_TYPE2)
           font->csi->supplement =
             MAX(opt->csi->supplement, font->csi->supplement);
         break;
       }
      } else if (CIDFont_is_BaseFont(font)) {
       opt->embed = 0;
       break;
      }
    }
  }

  if (font_id < __cache->num && cmap_csi) {
    if (strcmp(font->csi->registry, cmap_csi->registry) ||
       strcmp(font->csi->ordering, cmap_csi->ordering))
      ERROR("%s: Incompatible CMap for CIDFont \"%s\"",
           CIDFONT_DEBUG_STR, map_name);
  }

  if (font_id == __cache->num) {
    font = CIDFont_new();
    if (CIDFont_type0_open(font, map_name, cmap_csi, opt)    < 0 &&
       CIDFont_type2_open(font, map_name, cmap_csi, opt)    < 0 &&
       CIDFont_type0_t1open(font, map_name, cmap_csi, opt)  < 0 &&
       CIDFont_type0_t1copen(font, map_name, cmap_csi, opt) < 0 &&
       CIDFont_base_open (font, map_name, cmap_csi, opt)    < 0
       ) {
      CIDFont_release(font);
      release_opt(opt);
      return -1;
    } else {
      if (__cache->num >= __cache->max) {
       __cache->max  += CACHE_ALLOC_SIZE;
       __cache->fonts = RENEW(__cache->fonts,
                            __cache->max, struct CIDFont *);
      }
      font->name    = NEW(strlen(map_name)+1, char);
      strcpy(font->name,  map_name);
      font->ident   = NEW(strlen(map_name)+1, char);
      strcpy(font->ident, map_name);
      font->options = opt;
      __cache->fonts[font_id] = font;
      (__cache->num)++;
    }
  } else if (opt) {
    release_opt(opt);
  }

  return font_id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CIDFont* CIDFont_cache_get ( int  font_id)

Definition at line 543 of file cid.c.

{
  CHECK_ID(font_id);
  return __cache->fonts[font_id];
}

Here is the caller graph for this function:

void CIDFont_cache_init ( void  )

Definition at line 530 of file cid.c.

{
  if (__cache)
    ERROR("%s: Already initialized.", CIDFONT_DEBUG_STR);

  __cache = NEW(1, struct FontCache);

  __cache->max  = CACHE_ALLOC_SIZE;
  __cache->fonts = NEW(__cache->max, struct CIDFont *);
  __cache->num  = 0;
}

Here is the caller graph for this function:

static void CIDFont_dofont ( CIDFont font) [static]

Definition at line 338 of file cid.c.

{
  if (!font || !font->indirect)
    return;

  if (__verbose)
    MESG(":%s", font->ident);
  if (__verbose > 1) {
    if (font->fontname)
      MESG("[%s]", font->fontname);
  }

  switch (font->subtype) {
  case CIDFONT_TYPE0:
    if(__verbose)
      MESG("[CIDFontType0]");
    if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1))
      CIDFont_type0_t1dofont(font);
    else if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1C))
      CIDFont_type0_t1cdofont(font);
    else
      CIDFont_type0_dofont(font);
    break;
  case CIDFONT_TYPE2:
    if(__verbose)
      MESG("[CIDFontType2]");
    CIDFont_type2_dofont(font);
    break;
  default:
    ERROR("%s: Unknown CIDFontType %d.", CIDFONT_DEBUG_STR, font->subtype);
    break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CIDFont_flush ( CIDFont font)

Definition at line 159 of file cid.c.

{
  if (font) {
    if (font->indirect)   pdf_release_obj(font->indirect);
    font->indirect = NULL;
    if (font->fontdict)   pdf_release_obj(font->fontdict);
    font->fontdict = NULL;
    if (font->descriptor) pdf_release_obj(font->descriptor);
    font->descriptor = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 250 of file cid.c.

{
  ASSERT(font);

  return font->csi;
}

Here is the caller graph for this function:

int CIDFont_get_embedding ( CIDFont font)

Definition at line 243 of file cid.c.

{
  ASSERT(font);
  return font->options->embed;
}

Here is the caller graph for this function:

int CIDFont_get_flag ( CIDFont font,
int  mask 
)

Definition at line 331 of file cid.c.

{
  ASSERT(font);
  return ((font->flags & mask) ? 1 : 0);
}

Here is the caller graph for this function:

char* CIDFont_get_fontname ( CIDFont font)

Definition at line 206 of file cid.c.

{
  ASSERT(font);
  return font->fontname;
}

Here is the caller graph for this function:

char* CIDFont_get_ident ( CIDFont font)

Definition at line 213 of file cid.c.

{
  ASSERT(font);
  return font->ident;
}

Here is the caller graph for this function:

int CIDFont_get_opt_index ( CIDFont font)

Definition at line 220 of file cid.c.

{
  int  opt_index;

  ASSERT(font);

  if (font->options)
    opt_index = font->options->index;
  else {
    opt_index = 0;
  }

  return opt_index;
}

Here is the caller graph for this function:

int CIDFont_get_parent_id ( CIDFont font,
int  wmode 
)

Definition at line 262 of file cid.c.

{
  ASSERT(font);

  if (wmode < 0 || wmode > 1)
    ERROR("%s: Invalid wmode value.", CIDFONT_DEBUG_STR);

  return (font->parent)[wmode];
}

Here is the caller graph for this function:

Definition at line 273 of file cid.c.

{
  ASSERT(font);

  if (!font->indirect)
    font->indirect = pdf_ref_obj(font->fontdict);

  return pdf_link_obj(font->indirect);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CIDFont_get_subtype ( CIDFont font)

Definition at line 236 of file cid.c.

{
  ASSERT(font);
  return font->subtype;
}

Here is the caller graph for this function:

int CIDFont_is_ACCFont ( CIDFont font)

Definition at line 301 of file cid.c.

{
  int   i;

  ASSERT(font);

  if (!font->csi)
    ERROR("%s: CIDSystemInfo undefined.", CIDFONT_DEBUG_STR);

  for (i = ACC_START; i <= ACC_END ; i++) {
    if (!strcmp(font->csi->registry, CIDFont_stdcc_def[i].registry) &&
       !strcmp(font->csi->ordering, CIDFont_stdcc_def[i].ordering))
      return 1;
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CIDFont_is_BaseFont ( CIDFont font)

Definition at line 377 of file cid.c.

{
  ASSERT(font);
  return (font->flags & FONT_FLAG_BASEFONT) ? 1 : 0;
}

Here is the caller graph for this function:

int CIDFont_is_UCSFont ( CIDFont font)

Definition at line 320 of file cid.c.

{
  ASSERT(font);
  if (!strcmp(font->csi->ordering, "UCS") ||
      !strcmp(font->csi->ordering, "UCS2"))
    return 1;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CIDFont* CIDFont_new ( void  )

Definition at line 127 of file cid.c.

{
  CIDFont *font = NULL;

  font = NEW(1, struct CIDFont);

  font->name     = NULL;
  font->fontname = NULL;
  font->ident    = NULL;

  /*
   * CIDFont
   */
  font->subtype = -1;
  font->flags   = FONT_FLAG_NONE;
  font->csi     = NULL;
  font->options = NULL;
  (font->parent)[0] = -1; /* Horizontal */
  (font->parent)[1] = -1; /* Vertical   */

  /*
   * PDF Font Resource
   */
  font->indirect = NULL;
  font->fontdict = NULL;
  font->descriptor = NULL;

  return font;
}

Here is the caller graph for this function:

void CIDFont_release ( CIDFont font)

Definition at line 172 of file cid.c.

{
  if (font) {
    switch(font->subtype) {
    case CIDFONT_TYPE0:
      CIDFont_type0_release(font);
      break;
    case CIDFONT_TYPE2:
      CIDFont_type2_release(font);
      break;
    }
    if (font->indirect)
      ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR);
    if (font->fontdict)
      ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR);
    if (font->descriptor)
      ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR);

    if (font->fontname) RELEASE(font->fontname);
    if (font->name)     RELEASE(font->name);
    if (font->ident)    RELEASE(font->ident);
    if (font->csi) {
      if (font->csi->registry)
       RELEASE(font->csi->registry);
      if (font->csi->ordering)
       RELEASE(font->csi->ordering);
      RELEASE(font->csi);
    }
    if (font->options)
      release_opt(font->options);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CIDFont_set_flags ( long  flags)

Definition at line 800 of file cid.c.

Here is the call graph for this function:

void CIDFont_set_verbose ( void  )

Definition at line 111 of file cid.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static CIDSysInfo * get_cidsysinfo ( const char *  map_name,
fontmap_opt fmap_opt 
) [static]

Definition at line 709 of file cid.c.

{
  CIDSysInfo *csi = NULL;
  int pdf_ver;
  int i, csi_idx = -1, n, m;

  pdf_ver = pdf_get_version();

  if (!fmap_opt || !fmap_opt->charcoll)
    return NULL;

  /* First try alias for standard one. */
  for (i = 0; CIDFont_stdcc_alias[i].name != NULL; i++) {
    n = strlen(CIDFont_stdcc_alias[i].name);
    if (!strncmp(fmap_opt->charcoll,
               CIDFont_stdcc_alias[i].name, n)) {
      csi_idx  = CIDFont_stdcc_alias[i].index;
      csi = NEW(1, CIDSysInfo);
      csi->registry = NEW(strlen(CIDFont_stdcc_def[csi_idx].registry)+1, char);
      strcpy(csi->registry, CIDFont_stdcc_def[csi_idx].registry);
      csi->ordering = NEW(strlen(CIDFont_stdcc_def[csi_idx].ordering)+1, char);
      strcpy(csi->ordering, CIDFont_stdcc_def[csi_idx].ordering);
      if (strlen(fmap_opt->charcoll) > n) {
       csi->supplement = (int) strtoul(&(fmap_opt->charcoll[n]), NULL, 10);
      } else { /* Use heighest supported value for current output PDF version. */
       csi->supplement = CIDFont_stdcc_def[csi_idx].supplement[pdf_ver];
      }
      break;
    }
  }
  if (csi == NULL) {
    char *p, *q;

    p   = (char *) fmap_opt->charcoll;
    csi = NEW(1, CIDSysInfo);

    /* Full REGISTRY-ORDERING-SUPPLEMENT */
    p = strchr(fmap_opt->charcoll, '-');
    if (!p || p[1] == '\0')
      ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s",
           CIDFONT_DEBUG_STR, fmap_opt->charcoll);
    p++;

    q = strchr(p, '-');
    if (!q || q[1] == '\0')
      ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s",
           CIDFONT_DEBUG_STR, fmap_opt->charcoll);
    q++;

    if (!isdigit(q[0]))
      ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s",
           CIDFONT_DEBUG_STR, fmap_opt->charcoll);

    n = strlen(fmap_opt->charcoll) - strlen(p) - 1;
    csi->registry = NEW(n+1, char);
    memcpy(csi->registry, fmap_opt->charcoll, n);
    csi->registry[n] = '\0';

    m = strlen(p) - strlen(q) - 1;
    csi->ordering = NEW(m+1, char);
    memcpy(csi->ordering, p, m);
    csi->ordering[m] = '\0';

    csi->supplement = (int) strtoul(q, NULL, 10);

    /* Check for standart character collections. */
    for (i = 0; CIDFont_stdcc_def[i].ordering != NULL; i++) {
      if ((CIDFont_stdcc_def[i].registry &&
          !strcmp(csi->registry, CIDFont_stdcc_def[i].registry)) &&
         !strcmp(csi->ordering, CIDFont_stdcc_def[i].ordering)) {
       csi_idx = i;
       break;
      }
    }
  }

  if (csi && csi_idx >= 0) {
    if (csi->supplement > CIDFont_stdcc_def[csi_idx].supplement[pdf_ver]
       && (fmap_opt->flags & FONTMAP_OPT_NOEMBED)) {
      WARN("%s: Heighest supplement number supported in PDF-1.%d for %s-%s is %d.",
          CIDFONT_DEBUG_STR, pdf_ver, csi->registry, csi->ordering,
          CIDFont_stdcc_def[csi_idx].supplement[pdf_ver]);
      WARN("%s: Some character may not shown without embedded font (--> %s).",
          CIDFONT_DEBUG_STR, map_name);
    }
  }

  return csi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void release_opt ( cid_opt opt) [static]

Definition at line 696 of file cid.c.

{
  if (opt->csi) {
    if (opt->csi->registry)
      RELEASE(opt->csi->registry);
    if (opt->csi->ordering)
      RELEASE(opt->csi->ordering);
    RELEASE(opt->csi);
  }
  RELEASE(opt);
}

Here is the caller graph for this function:


Variable Documentation

struct FontCache* __cache = NULL [static]

Definition at line 520 of file cid.c.

int __verbose = 0 [static]

Definition at line 107 of file cid.c.

struct { ... } CIDFont_stdcc_alias[] [static]
struct { ... } CIDFont_stdcc_def[] [static]
long cidoptflags = 0 [static]

Definition at line 108 of file cid.c.

Initial value:
 {
  (char *) "Adobe",
  (char *) "Identity",
  0
}

Definition at line 79 of file cid.c.

Initial value:
 {
  (char *) "Adobe",
  (char *) "UCS",
  0
}

Definition at line 85 of file cid.c.