Back to index

tetex-bin  3.0
Classes | Defines | Typedefs | Functions | Variables
pdfdoc.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "system.h"
#include "config.h"
#include "mem.h"
#include "error.h"
#include "mfileio.h"
#include "numbers.h"
#include "dvi.h"
#include "pdflimits.h"
#include "pdfobj.h"
#include "pdfdev.h"
#include "pdfdoc.h"
#include "pdfspecial.h"

Go to the source code of this file.

Classes

struct  pages
struct  dests
struct  articles
struct  resource_stack

Defines

#define timezone   0l
#define BANNER   "dvipdfm %s, Copyright \251 1998, by Mark A. Wicks"
#define PAGE_CLUSTER   4
#define CLUSTER   4

Typedefs

typedef struct dests = NULL
typedef struct articles

Functions

static void start_page_tree (void)
static void create_catalog (void)
static void start_current_page_resources (void)
static void finish_page_tree (void)
static void start_name_tree (void)
static void finish_dests_tree (void)
static void finish_pending_xobjects (void)
static void start_articles (void)
void pdf_doc_set_verbose (void)
void pdf_doc_set_debug (void)
static void resize_pages (unsigned long newsize)
static void make_short_cuts (void)
static void release_short_cuts (void)
void pdf_doc_bop (char *string, unsigned length)
void pdf_doc_this_bop (char *string, unsigned length)
void pdf_doc_set_origin (double x, double y)
void pdf_doc_eop (char *string, unsigned length)
static void start_outline_tree (void)
static char * asn_date (void)
static void create_docinfo (void)
static void finish_docinfo (void)
void pdf_doc_merge_with_docinfo (pdf_obj *dictionary)
void pdf_doc_merge_with_catalog (pdf_obj *dictionary)
void pdf_doc_add_to_page_fonts (const char *name, pdf_obj *resource)
void pdf_doc_add_to_page_xobjects (const char *name, pdf_obj *resource)
void pdf_doc_add_to_page_resources (const char *name, pdf_obj *resource)
void pdf_doc_add_to_page_annots (pdf_obj *annot)
static pdf_objpage_subtree (struct pages *pages, unsigned long npages, pdf_obj *parent_ref)
void pdf_doc_change_outline_depth (int new_depth)
static void finish_outline (void)
void pdf_doc_add_outline (pdf_obj *dict)
static int CDECL cmp_dest (const void *d1, const void *d2)
static pdf_objname_subtree (dest_entry *dests, unsigned long ndests)
void pdf_doc_add_dest (char *name, unsigned length, pdf_obj *array_ref)
void pdf_doc_start_article (char *name, pdf_obj *info)
void pdf_doc_add_bead (char *article_name, pdf_obj *partial_dict)
void finish_articles (void)
void pdf_doc_finish_page ()
pdf_objpdf_doc_current_page_resources (void)
pdf_objpdf_doc_ref_page (unsigned long page_no)
pdf_objpdf_doc_names (void)
pdf_objpdf_doc_page_tree (void)
pdf_objpdf_doc_catalog (void)
pdf_objpdf_doc_this_page (void)
pdf_objpdf_doc_this_page_ref (void)
pdf_objpdf_doc_prev_page_ref (void)
pdf_objpdf_doc_next_page_ref (void)
void pdf_doc_new_page (void)
void pdf_doc_add_to_page (char *buffer, unsigned length)
void pdf_doc_init (char *filename)
void pdf_doc_creator (char *s)
void pdf_doc_close ()
static pdf_objbuild_scale_array (double a, double b, double c, double d, double e, double f)
void doc_make_form_xobj (pdf_obj *this_form_contents, pdf_obj *bbox, double refptx, double refpty, double xscale, double yscale, pdf_obj *resources, char *form_name)
pdf_objbegin_form_xobj (double xpos, double ypos, double bbllx, double bblly, double bburx, double bbury, char *res_name)
void end_form_xobj (void)
void pdf_doc_set_box (void)
void pdf_doc_begin_annot (pdf_obj *dict)
void pdf_doc_end_annot (void)
void pdf_doc_flush_annot (void)
void pdf_doc_expand_box (double llx, double lly, double urx, double ury)

Variables

static pdf_objcatalog = NULL
static pdf_objdocinfo = NULL
static pdf_objpage_tree = NULL
static pdf_objpage_tree_ref = NULL
int outline_depth = 0
struct {
int kid_count
pdf_objentry
outline [MAX_OUTLINE_DEPTH]
static pdf_objcurrent_page_resources = NULL
static pdf_objthis_page_contents = NULL
static pdf_objglob_page_bop
static pdf_objglob_page_eop
static pdf_objcoord_xform_stream = NULL
static pdf_objcoord_xform_ref = NULL
static pdf_objthis_page_bop = NULL
static pdf_objthis_page_beads = NULL
static pdf_objthis_page_annots = NULL
static pdf_objthis_page_xobjects = NULL
static pdf_objthis_page_fonts = NULL
static pdf_objtmp1
static unsigned long page_count = 0
static struct pagespages
static unsigned long max_pages = 0
static unsigned char verbose = 0
static unsigned char debug = 0
static pdf_objtype_name
static pdf_objpage_name
static pdf_objpages_name
static pdf_objcontents_name
static pdf_objannots_name
static pdf_objresources_name
static pdf_objbead_name
static pdf_objcount_name
static pdf_objkids_name
static pdf_objparent_name
static pdf_objmediabox_name
static pdf_objlimits_name
static pdf_objthumb_name
static pdf_objnames_dict
unsigned long max_dests = 0
static unsigned long number_dests = 0
static unsigned long number_articles = 0
static pdf_objarticles_array
static int highest_page_ref = 0
struct resource_stack res_stack [4]
static int xobjects_pending = 0
struct {
pdf_objannot_dict
unsigned char dirty
double llx
double lly
double urx
double ury
breaking_state

Class Documentation

struct pages

Definition at line 69 of file pdfdoc.c.

Collaboration diagram for pages:
Class Members
pdf_obj * page_dict
pdf_obj * page_ref
struct dests

Definition at line 581 of file pdfdoc.c.

Collaboration diagram for dests:
Class Members
pdf_obj * array
unsigned length
char * name
struct articles

Definition at line 683 of file pdfdoc.c.

Collaboration diagram for articles:
Class Members
pdf_obj * first
pdf_obj * info
pdf_obj * last
char * name
pdf_obj * this
struct resource_stack

Definition at line 1118 of file pdfdoc.c.

Collaboration diagram for resource_stack:
Class Members
pdf_obj * save_page_contents
pdf_obj * save_page_fonts
pdf_obj * save_page_resources
pdf_obj * save_page_xobjects
int xform_depth

Define Documentation

#define BANNER   "dvipdfm %s, Copyright \251 1998, by Mark A. Wicks"

Definition at line 257 of file pdfdoc.c.

#define CLUSTER   4
#define PAGE_CLUSTER   4
#define timezone   0l

Typedef Documentation

static article_entry articles

Definition at line 692 of file pdfdoc.c.

static dest_entry * dests = NULL

Definition at line 587 of file pdfdoc.c.


Function Documentation

static char* asn_date ( void  ) [static]

Definition at line 233 of file pdfdoc.c.

{
#ifndef HAVE_TIMEZONE
  #ifdef TM_GM_TOFF
     #define timezone (bdtime->gm_toff)
  #else
     #define timezone 0l
#endif /* TM_GM_TOFF */
#endif /* HAVE_TIMEZONE */
  static char date_string[24];
  time_t current_time;
  struct tm *bd_time;
  if (debug) {
    fprintf (stderr, "(asn_date)");
  }
  time(&current_time);
  bd_time = localtime(&current_time);
  sprintf (date_string, "D:%04d%02d%02d%02d%02d%02d%+03ld'%02ld'",
          bd_time -> tm_year+1900, bd_time -> tm_mon+1, bd_time -> tm_mday,
          bd_time -> tm_hour, bd_time -> tm_min, bd_time -> tm_sec,
          -timezone/3600, timezone%3600);
  return date_string;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pdf_obj* begin_form_xobj ( double  xpos,
double  ypos,
double  bbllx,
double  bblly,
double  bburx,
double  bbury,
char *  res_name 
)

Definition at line 1130 of file pdfdoc.c.

{
  pdf_obj *bbox;
  if (xobjects_pending >= sizeof(res_stack)/sizeof(res_stack[0])) {
    fprintf (stderr, "\nForm XObjects nested too deeply.  Limit is %d\n",
            sizeof(res_stack)/sizeof(res_stack[0]));
    return NULL;
  }
  /* This is a real hack.  We basically treat each xobj as a separate mini
     page unto itself.  Save all the page structures and reinitialize
     them when we finish this xobject. */
  res_stack[xobjects_pending].save_page_resources = current_page_resources;
  current_page_resources = NULL;
  res_stack[xobjects_pending].save_page_xobjects = this_page_xobjects;
  this_page_xobjects = NULL;
  res_stack[xobjects_pending].save_page_fonts = this_page_fonts;
  this_page_fonts = NULL;
  res_stack[xobjects_pending].save_page_contents = this_page_contents;
  this_page_contents = NULL;
  res_stack[xobjects_pending].xform_depth = dev_xform_depth();
  xobjects_pending += 1;
  start_current_page_resources(); /* Starts current_page_resources */
  this_page_contents = pdf_new_stream (STREAM_COMPRESS);
  /* Make a bounding box for this Xobject */
  /* Translate coordinate system so reference point of object 
     is at 0 */
  bbox = pdf_new_array ();
  pdf_add_array (bbox, pdf_new_number (ROUND(bbllx,0.01)));
  pdf_add_array (bbox, pdf_new_number (ROUND(bblly,0.01)));
  pdf_add_array (bbox, pdf_new_number (ROUND(bburx,0.01)));
  pdf_add_array (bbox, pdf_new_number (ROUND(bbury,0.01)));
  /* Resource is already made, so call doc_make_form_xobj() */
  doc_make_form_xobj (this_page_contents, bbox,
                    xpos, ypos, 1.0, 1.0,
                    pdf_ref_obj(current_page_resources), res_name);
  /* Make sure the object is self-contained by adding the
     current font to the object stream */
  dev_reselect_font();
  /* Likewise for color */
  dev_do_color();
  return pdf_link_obj (this_page_contents);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static pdf_obj* build_scale_array ( double  a,
double  b,
double  c,
double  d,
double  e,
double  f 
) [static]

Definition at line 1072 of file pdfdoc.c.

{
  pdf_obj *result;
  result = pdf_new_array();
  pdf_add_array (result, pdf_new_number (a));
  pdf_add_array (result, pdf_new_number (b));
  pdf_add_array (result, pdf_new_number (c));
  pdf_add_array (result, pdf_new_number (d));
  pdf_add_array (result, pdf_new_number (ROUND(e,0.01)));
  pdf_add_array (result, pdf_new_number (ROUND(f,0.01)));
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int CDECL cmp_dest ( const void d1,
const void d2 
) [static]

Definition at line 591 of file pdfdoc.c.

{
  unsigned length;
  int tmp;
  length = MIN (((dest_entry *) d1) -> length, ((dest_entry *) d2) ->
              length);
  if ((tmp = memcmp (((dest_entry *) d1) -> name, ((dest_entry *) d2)
                    -> name, length)) != 0)
    return tmp;
  if (((dest_entry *) d1) -> length == ((dest_entry *) d2) -> length)
    return 0;
  return (((dest_entry *) d1) -> length < ((dest_entry *) d2) -> length ? -1 : 1 );
}

Here is the caller graph for this function:

static void create_catalog ( void  ) [static]

Definition at line 297 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(create_catalog)");
  }
  catalog = pdf_new_dict ();
  pdf_set_root (catalog);
  /* Create /Type attribute */
  pdf_add_dict (catalog,
              pdf_link_obj (type_name),
              pdf_new_name("Catalog"));
 /* Create only those parts of the page tree required for the catalog.
    That way, the rest of the page tree can be finished at any time */
  start_page_tree(); 
  /* Likewise for outline tree */
  start_outline_tree ();
  start_name_tree();
  start_articles();
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void create_docinfo ( void  ) [static]

Definition at line 258 of file pdfdoc.c.

{
  /* Create an empty Info entry and make it
     be the root object */
  if (debug) {
    fprintf (stderr, "(create_docinfo)");
  }
  docinfo = pdf_new_dict ();
  pdf_set_info (docinfo);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void doc_make_form_xobj ( pdf_obj this_form_contents,
pdf_obj bbox,
double  refptx,
double  refpty,
double  xscale,
double  yscale,
pdf_obj resources,
char *  form_name 
)

Definition at line 1092 of file pdfdoc.c.

{
  pdf_obj *xobj_dict, *tmp1;
  xobj_dict = pdf_stream_dict (this_form_contents);
  
  pdf_add_dict (xobj_dict, pdf_new_name ("Name"), pdf_new_name(form_name));
  pdf_add_dict (xobj_dict, pdf_link_obj (type_name),
              pdf_new_name ("XObject"));
  pdf_add_dict (xobj_dict, pdf_new_name ("Subtype"),
              pdf_new_name ("Form"));
  pdf_add_dict (xobj_dict, pdf_new_name ("BBox"), bbox);
  pdf_add_dict (xobj_dict, pdf_new_name ("FormType"), 
              pdf_new_number(1.0));
  /* The reference point of an Xobject is at the lower left corner
     of the bounding box.  Since we would like to have an arbitrary
     reference point, we use a transformation matrix, translating
     the reference point to (0,0) */
  tmp1 = build_scale_array (xscale, 0, 0, yscale, -xscale*refptx, -yscale*refpty);
  pdf_add_dict (xobj_dict, pdf_new_name ("Matrix"), tmp1);
  pdf_add_dict (xobj_dict, pdf_link_obj (resources_name), resources);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1175 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 772 of file pdfdoc.c.

{
  int i;
  pdf_add_dict (catalog,
              pdf_new_name ("Threads"),
              pdf_ref_obj (articles_array));
  pdf_release_obj (articles_array);
  for (i=0; i<number_articles; i++) {
    if (articles[i].last == NULL) {
      fprintf (stderr, "Article started, but no beads\n");
      break;
    }
    /* Close the loop */
    pdf_add_dict (articles[i].last,
                pdf_new_name ("N"),
                pdf_ref_obj (articles[i].first));
    pdf_add_dict (articles[i].first,
                pdf_new_name ("V"),
                pdf_ref_obj (articles[i].last));
    pdf_release_obj (articles[i].first);
    pdf_release_obj (articles[i].last);
    pdf_release_obj (articles[i].info);
    RELEASE (articles[i].name);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void finish_dests_tree ( void  ) [static]

Definition at line 646 of file pdfdoc.c.

{
  pdf_obj *kid;
  if (number_dests > 0) {
    /* Sort before writing any /Dests entries */
    qsort(dests, number_dests, sizeof(dests[0]), cmp_dest);
    kid = name_subtree (dests, number_dests);
    /* Each entry in dests has been assigned to another object, so
       we can free the entire array without freeing the entries. */
    RELEASE (dests);
    pdf_add_dict (names_dict,
                pdf_new_name ("Dests"),
                pdf_ref_obj (kid));
    pdf_release_obj (kid);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void finish_docinfo ( void  ) [static]

Definition at line 270 of file pdfdoc.c.

{
  char *time_string, *banner;
  banner = NEW (strlen(BANNER)+20,char);
  sprintf(banner, BANNER, VERSION);
  pdf_add_dict (docinfo, 
              pdf_new_name ("Producer"),
              pdf_new_string (banner, strlen (banner)));
  RELEASE (banner);
  time_string = asn_date();
  pdf_add_dict (docinfo, 
              pdf_new_name ("CreationDate"),
              pdf_new_string (time_string, strlen (time_string)));
  pdf_release_obj (docinfo);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void finish_outline ( void  ) [static]

Definition at line 525 of file pdfdoc.c.

{
  if (debug)
    fprintf (stderr, "(finish_outline)");
  /* Link it into the catalog */
  /* Point /Outline attribute to indirect reference */
  pdf_doc_change_outline_depth (0);
  pdf_add_dict (catalog,
              pdf_new_name ("Outlines"),
              pdf_ref_obj(outline[outline_depth].entry));
  pdf_release_obj (outline[0].entry);
  outline[0].entry = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void finish_page_tree ( void  ) [static]

Definition at line 452 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1209 of file pdfdoc.c.

{
  if (xobjects_pending) {
    fprintf (stderr, "\nFinishing a pending form XObject at end of page\n"); 
    while (xobjects_pending--) {
      end_form_xobj();
    }
  }
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_short_cuts ( void  ) [static]

Definition at line 114 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
MEM_START
#endif
  /* Define some shorthand for names that will conserve memory (and time)
     (similar to the latex \@ne trick */
  type_name = pdf_new_name("Type");
  page_name = pdf_new_name("Page");
  pages_name = pdf_new_name("Pages");
  count_name = pdf_new_name("Count");
  kids_name = pdf_new_name("Kids");
  parent_name = pdf_new_name("Parent");
  contents_name = pdf_new_name("Contents");
  annots_name = pdf_new_name("Annots");
  resources_name = pdf_new_name ("Resources");
  bead_name = pdf_new_name ("B");
  mediabox_name = pdf_new_name ("MediaBox");
  limits_name = pdf_new_name ("Limits");
  thumb_name = pdf_new_name ("Thumb");
#ifdef MEM_DEBUG
MEM_END
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static pdf_obj* name_subtree ( dest_entry *  dests,
unsigned long  ndests 
) [static]

Definition at line 605 of file pdfdoc.c.

{
#define CLUSTER 4
  pdf_obj *result, *name_array, *limit_array, *kid_array;
  result = pdf_new_dict();
  limit_array = pdf_new_array();
  pdf_add_dict (result, pdf_link_obj(limits_name), limit_array);
  pdf_add_array (limit_array, pdf_new_string(dests[0].name,
                                        dests[0].length)); 
  pdf_add_array (limit_array, pdf_new_string(dests[ndests-1].name,
                                        dests[ndests-1].length));
  if (ndests > 0 && ndests <= CLUSTER) {
    int i;
    name_array = pdf_new_array();
    pdf_add_dict (result, pdf_new_name ("Names"),
                name_array);
    for (i=0; i<ndests; i++) {
      pdf_add_array (name_array, pdf_new_string (dests[i].name,
                                           dests[i].length));
      RELEASE (dests[i].name);
      pdf_add_array (name_array, dests[i].array);
    }
  } else if (ndests > 0) {
    int i;
    kid_array = pdf_new_array();
    pdf_add_dict (result, pdf_link_obj (kids_name), kid_array);
    for (i=0; i<CLUSTER; i++) {
      pdf_obj *subtree;
      unsigned long start, end;
      start = (i*ndests)/CLUSTER;
      end = ((i+1)*ndests)/CLUSTER;
      subtree = name_subtree (dests+start, end-start);
      pdf_add_array (kid_array, pdf_ref_obj (subtree));
      pdf_release_obj (subtree);
    }
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static pdf_obj* page_subtree ( struct pages pages,
unsigned long  npages,
pdf_obj parent_ref 
) [static]

Definition at line 389 of file pdfdoc.c.

{
#define PAGE_CLUSTER 4
  pdf_obj *self, *self_ref, *kid_array;
  self = pdf_new_dict();
  /* This is a slight kludge which allow the subtree
     dictionary generated by this routine to be merged with the
     real page_tree dictionary, while keeping the indirect 
     object references right */
  if (parent_ref == NULL)
    self_ref = pdf_ref_obj (page_tree);
  else
    self_ref = pdf_ref_obj (self);
  pdf_add_dict (self, pdf_link_obj (type_name),
              pdf_link_obj (pages_name));
  pdf_add_dict (self, pdf_link_obj (count_name),
              pdf_new_number((double) npages));
  kid_array = pdf_new_array();
  pdf_add_dict (self, pdf_link_obj (kids_name), 
              kid_array);
  if (parent_ref != NULL) {
    pdf_add_dict (self, pdf_link_obj(parent_name),
                parent_ref);
  }
  if (npages > 0 && npages <= PAGE_CLUSTER) {
    int i;
    for (i=0; i<npages; i++) {
      pdf_add_array (kid_array, pdf_link_obj(pages[i].page_ref));
      pdf_add_dict (pages[i].page_dict, pdf_link_obj (parent_name),
                  pdf_link_obj(self_ref));
      pdf_release_obj (pages[i].page_dict);
      pdf_release_obj (pages[i].page_ref);
      pages[i].page_dict = NULL;
      pages[i].page_ref = NULL;
    }
  } else if (npages > 0) {
    int i;
    for (i=0; i<PAGE_CLUSTER; i++) {
      pdf_obj *subtree;
      unsigned long start, end;
      start = (i*npages)/PAGE_CLUSTER;
      end = ((i+1)*npages)/PAGE_CLUSTER;
      if (end-start>1) {
       subtree = page_subtree (pages+start, end-start, pdf_link_obj(self_ref));
       pdf_add_array (kid_array, pdf_ref_obj (subtree));
       pdf_release_obj (subtree);
      }
      else {
       pdf_add_array (kid_array, pdf_link_obj(pages[start].page_ref));
       pdf_add_dict (pages[start].page_dict, pdf_link_obj(parent_name),
                    pdf_link_obj (self_ref));
       pdf_release_obj (pages[start].page_dict);
       pdf_release_obj (pages[start].page_ref);
       pages[start].page_dict = NULL;
       pages[start].page_ref = NULL;
      }
    }
  }
  pdf_release_obj (self_ref);
  return self;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_add_bead ( char *  article_name,
pdf_obj partial_dict 
)

Definition at line 721 of file pdfdoc.c.

{
  /* partial_dict should have P (Page) and R (Rect) already filled in */
  /* See if the specified article exists */
  int i;
  for (i=0; i<number_articles; i++) {
    if (!strcmp (articles[i].name, article_name))
      break;
  }
  if (i == number_articles) {
    fprintf (stderr, "Bead specified thread that doesn't exist\n");
    return;
  }
  /* Is this the first bead? */
  if (articles[i].last == NULL) {
    articles[i].first = pdf_link_obj (partial_dict);
    /* Add pointer to its first object */ 
    pdf_add_dict (articles[i].this,
                pdf_new_name ("F"),
                pdf_ref_obj (articles[i].first));
    /* Next add pointer to its Info dictionary */
    pdf_add_dict (articles[i].this,
                pdf_new_name ("I"),
                pdf_ref_obj (articles[i].info));
    /* Point first bead to parent article */
    pdf_add_dict (partial_dict,
                pdf_new_name ("T"),
                pdf_ref_obj (articles[i].this));
    /* Ship it out and forget it */
    pdf_add_array (articles_array, pdf_ref_obj (articles[i].this));
    pdf_release_obj (articles[i].this);
    articles[i].this = NULL;
  } else {
    /* Link it in... */
    /* Point last object to this one */
    pdf_add_dict (articles[i].last,
                pdf_new_name ("N"),
                pdf_ref_obj (partial_dict));
    /* Point this one to last */
    pdf_add_dict (partial_dict,
                pdf_new_name ("V"),
                pdf_ref_obj (articles[i].last));
    pdf_release_obj (articles[i].last);
  }
  articles[i].last = partial_dict;
  if (this_page_beads == NULL)
    this_page_beads = pdf_new_array();
  pdf_add_array (this_page_beads,
               pdf_ref_obj (partial_dict));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_add_dest ( char *  name,
unsigned  length,
pdf_obj array_ref 
)

Definition at line 663 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
MEM_START
#endif
  if (number_dests >= max_dests) {
    max_dests += DESTS_ALLOC_SIZE;
    dests = RENEW (dests, max_dests, dest_entry);
  }
  dests[number_dests].name = NEW (length, char);
  memcpy (dests[number_dests].name, name, length);
  dests[number_dests].length = length;
  dests[number_dests].array = array_ref;
  number_dests++;
#ifdef MEM_DEBUG
MEM_END
#endif
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 540 of file pdfdoc.c.

{
  pdf_obj *new_entry;
  if (outline_depth < 1)
    ERROR ("Can't add to outline at depth < 1");
  new_entry = pdf_new_dict ();
  pdf_merge_dict (new_entry, dict);
  /* Caller doesn't know we don't actually use the dictionary,
     so he *gave* dict to us.  We have to free it */
  pdf_release_obj (dict);
  /* Tell it where its parent is */
  pdf_add_dict (new_entry,
              pdf_link_obj (parent_name),
              pdf_ref_obj (outline[outline_depth-1].entry));
  /* Give mom and dad the good news */
  outline[outline_depth-1].kid_count += 1;

  /* Is this the first entry at this depth? */
  if (outline[outline_depth].entry == NULL) {
    /* Is so, tell the parent we are first born */
    pdf_add_dict (outline[outline_depth-1].entry,
                pdf_new_name ("First"),
                pdf_ref_obj (new_entry));
  }
  else {
    /* Point us back to sister */
    pdf_add_dict (new_entry,
                pdf_new_name ("Prev"),
                pdf_ref_obj (outline[outline_depth].entry));
    /* Point our elder sister toward us */
    pdf_add_dict (outline[outline_depth].entry,
                pdf_new_name ("Next"),
                pdf_ref_obj (new_entry));
    /* Bye-Bye sis */
    pdf_release_obj (outline[outline_depth].entry);
  }
  outline[outline_depth].entry = new_entry;
  /* Just born, so don't have any kids */
  outline[outline_depth].kid_count = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_add_to_page ( char *  buffer,
unsigned  length 
)

Definition at line 996 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 378 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(pdf_doc_add_to_page_annots)");
  }
  if (this_page_annots == NULL)
    this_page_annots = pdf_new_array ();
  pdf_add_array (this_page_annots,
               annot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_add_to_page_fonts ( const char *  name,
pdf_obj resource 
)

Definition at line 335 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
  MEM_START;
#endif

  if (debug) {
    fprintf (stderr, "(pdf_doc_add_to_page_fonts)");
  }
  if (this_page_fonts == NULL)
    this_page_fonts = pdf_new_dict();
  pdf_add_dict (this_page_fonts,
              pdf_new_name (name), resource);
#ifdef MEM_DEBUG
MEM_END
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_add_to_page_resources ( const char *  name,
pdf_obj resource 
)

Definition at line 368 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(pdf_doc_add_to_page_resources)");
  }
  pdf_add_dict (current_page_resources,
              pdf_new_name (name), 
              resource);
}

Here is the call graph for this function:

void pdf_doc_add_to_page_xobjects ( const char *  name,
pdf_obj resource 
)

Definition at line 354 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(pdf_doc_add_to_page_xojects)");
  }
  if (this_page_xobjects == NULL)
    this_page_xobjects = pdf_new_dict ();
  pdf_add_dict (this_page_xobjects,
              pdf_new_name (name), 
              resource);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1237 of file pdfdoc.c.

{
  breaking_state.annot_dict = dict;
  pdf_doc_set_box ();
  dev_tag_depth ();
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_bop ( char *  string,
unsigned  length 
)

Definition at line 177 of file pdfdoc.c.

{
  if (length > 0)
    pdf_add_stream (glob_page_bop, string, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 930 of file pdfdoc.c.

{
  return catalog;
}

Here is the caller graph for this function:

Definition at line 487 of file pdfdoc.c.

{
  int i;
  if (debug) {
    fprintf (stderr, "(change_outline_depth)");
  }
  if (outline_depth >= MAX_OUTLINE_DEPTH -1)
    ERROR ("Outline is too deep.");
  if (new_depth == outline_depth)
    /* Nothing to do */
    return;
  if (new_depth > outline_depth+1)
    ERROR ("Can't increase outline depth by more than one at a time\n");
  if (outline[outline_depth].entry == NULL)
    ERROR ("change_outline_depth: Fix me, I'm broke. This shouldn't happen!");
  /* Terminate all entries above this depth */
  for (i=outline_depth-1; i>=new_depth; i--) {
    pdf_add_dict (outline[i].entry,
                pdf_new_name ("Last"),
                pdf_ref_obj (outline[i+1].entry));
    if (i > 0) 
      tmp1 = pdf_new_number (-outline[i].kid_count);
    else
      tmp1 = pdf_new_number (outline[i].kid_count);

    pdf_add_dict (outline[i].entry,
                pdf_link_obj (count_name),
                tmp1);
  }
  /* Flush out all entries above this depth */
  for (i=new_depth+1; i<=outline_depth; i++) {
    pdf_release_obj (outline[i].entry);
    outline[i].entry = NULL;
    outline[i].kid_count = 0;
  }
  outline_depth = new_depth;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1035 of file pdfdoc.c.

{
  if (debug) fprintf (stderr, "pdf_doc_finish:\n");
#ifdef HAVE_LIBPNG
  if (thumb_basename)
    RELEASE (thumb_basename);
#endif /* HAVE_LIBPNG */
  /* Following things were kept around so user can add dictionary
     items */
  finish_docinfo();
  finish_page_tree();
  /* Add names dict to catalog */
  finish_outline();
  finish_dests_tree();
  finish_articles();
  pdf_add_dict (catalog,
              pdf_new_name ("Names"),
              pdf_ref_obj (names_dict));
  pdf_release_obj (names_dict);
  pdf_release_obj (catalog);
  /* Do consistency check on forward references to pages */
  if (highest_page_ref > page_count) {
    unsigned long i;
    fprintf (stderr, "\nWarning:  Nonexistent page(s) referenced\n");
    fprintf (stderr, "          (PDF file may not work right)\n");
    for (i=page_count; i<highest_page_ref; i++) {
      if (pages[i].page_dict) {
       pdf_release_obj (pages[i].page_dict);
       pdf_release_obj (pages[i].page_ref);
      }
    }
  }
  pdf_finish_specials();
  release_short_cuts();
  pdf_out_flush ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_creator ( char *  s)

Definition at line 1029 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 894 of file pdfdoc.c.

Here is the caller graph for this function:

Definition at line 1245 of file pdfdoc.c.

{
  pdf_doc_flush_annot();
  breaking_state.annot_dict = NULL;
  dev_untag_depth ();
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_eop ( char *  string,
unsigned  length 
)

Definition at line 206 of file pdfdoc.c.

{
  if (length > 0)
    pdf_add_stream (glob_page_eop, string, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_expand_box ( double  llx,
double  lly,
double  urx,
double  ury 
)

Definition at line 1275 of file pdfdoc.c.

Here is the caller graph for this function:

Definition at line 809 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
MEM_START
#endif  
  if (debug) {
    fprintf (stderr, "(pdf_doc_finish_page)");
  }
  finish_pending_xobjects();
  /* Flush this page */
  /* Page_count is the index of the current page, starting at 1 */
  tmp1 = pdf_new_array ();
  pdf_add_array (tmp1, pdf_ref_obj (glob_page_bop));
  if (this_page_bop) {
    pdf_add_array (tmp1, pdf_ref_obj (this_page_bop));
  }
  pdf_add_array (tmp1, pdf_link_obj (coord_xform_ref));
  pdf_add_array (tmp1, pdf_ref_obj (this_page_contents));
  pdf_add_array (tmp1, pdf_ref_obj (glob_page_eop));
  pdf_add_dict (pages[page_count].page_dict,
              pdf_link_obj(contents_name), tmp1);
  /* We keep .page_dict open because we don't know the parent yet */
  if (this_page_bop != NULL) {
    pdf_add_stream (this_page_bop, "\n", 1);
    pdf_release_obj (this_page_bop);
    this_page_bop = NULL;
  }
  if (this_page_contents != NULL) {
    pdf_add_stream (this_page_contents, "\n", 1);
    pdf_release_obj (this_page_contents);
    this_page_contents = NULL;
  }
  if (this_page_annots != NULL) {
    pdf_add_dict (pages[page_count].page_dict,
                pdf_link_obj(annots_name),
                pdf_ref_obj (this_page_annots));
    pdf_release_obj (this_page_annots);
    this_page_annots = NULL;
  }
  if (this_page_beads != NULL) {
    pdf_add_dict (pages[page_count].page_dict,
                pdf_link_obj (bead_name),
                pdf_ref_obj (this_page_beads));
    pdf_release_obj (this_page_beads);
    this_page_beads = NULL;
  }
  if (this_page_fonts != NULL) {
    pdf_add_dict (current_page_resources, 
                pdf_new_name ("Font"),
                pdf_ref_obj (this_page_fonts));
    pdf_release_obj (this_page_fonts);
    this_page_fonts = NULL;
  }
  if (this_page_xobjects != NULL) {
    pdf_add_dict (current_page_resources,
                pdf_new_name ("XObject"),
                pdf_ref_obj (this_page_xobjects));
    pdf_release_obj (this_page_xobjects);
    this_page_xobjects = NULL;
  }
  if (current_page_resources != NULL) {
    pdf_release_obj (current_page_resources);
    current_page_resources = NULL;
  }
#ifdef HAVE_LIBPNG
  if (thumbnail_opt) {
    char *thumb_filename;
    pdf_obj *thumbnail;
    thumb_filename = NEW (strlen(thumb_basename)+7, char);
    sprintf (thumb_filename, "%s.%ld", thumb_basename,
            page_count%99999+1L);
    thumbnail = do_thumbnail (thumb_filename);
    RELEASE (thumb_filename);
    if (thumbnail) 
      pdf_add_dict (pages[page_count].page_dict,
                  pdf_link_obj (thumb_name),
                  thumbnail);
  }
#endif
  page_count += 1;
#ifdef MEM_DEBUG
  MEM_END;
#endif  
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1253 of file pdfdoc.c.

{
  pdf_obj *rectangle, *new_dict;
  double grow;
  grow = pdf_special_tell_grow ();
  if (breaking_state.dirty) {
    rectangle = pdf_new_array ();
    pdf_add_array (rectangle, pdf_new_number(ROUND(breaking_state.llx-grow, 0.01)));
    pdf_add_array (rectangle, pdf_new_number(ROUND(breaking_state.lly-grow, 0.01)));
    pdf_add_array (rectangle, pdf_new_number(ROUND(breaking_state.urx+grow, 0.01)));
    pdf_add_array (rectangle, pdf_new_number(ROUND(breaking_state.ury+grow, 0.01)));
    new_dict = pdf_new_dict ();
    pdf_add_dict (new_dict, pdf_new_name ("Rect"),
                rectangle);
    pdf_merge_dict (new_dict, breaking_state.annot_dict);
    pdf_doc_add_to_page_annots (pdf_ref_obj (new_dict));
    pdf_release_obj (new_dict);
  }
  pdf_doc_set_box();
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_init ( char *  filename)

Definition at line 1001 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
  MEM_START
#endif
  if (debug) fprintf (stderr, "pdf_doc_init:\n");
  pdf_out_init (filename);
#ifdef HAVE_LIBPNG
  /* Create a default name for thumbnail image files */
  if (thumbnail_opt) {
    if (strlen(filename)>4 && !strncmp (".pdf", filename+strlen(filename)-4,4)) {
      thumb_basename = NEW (strlen(filename)+1-4, char);
      strncpy (thumb_basename, filename, strlen(filename)-4);
      thumb_basename[strlen(filename)-4] = 0;
    } else {
      thumb_basename = NEW (strlen(filename)+1, char);
      strcpy (thumb_basename, filename);
    }
  }
#endif /* HAVE_LIBPNG */
  make_short_cuts();
  create_docinfo ();
  create_catalog ();
#ifdef MEM_DEBUG
  MEM_END
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 292 of file pdfdoc.c.

{
  pdf_merge_dict (catalog, dictionary);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 287 of file pdfdoc.c.

{
  pdf_merge_dict (docinfo, dictionary);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 920 of file pdfdoc.c.

{
  return names_dict;
}

Here is the caller graph for this function:

Definition at line 958 of file pdfdoc.c.

{
#ifdef MEM_DEBUG
MEM_START
#endif
  if (debug) {
    fprintf (stderr, "(pdf_doc_new_page)");
    fprintf (stderr, "page_count=%ld, max_pages=%ld\n", page_count,
            max_pages);
  }
  /* See if we need more pages allocated yet */
  if (page_count >= max_pages) {
    resize_pages(max_pages+PAGES_ALLOC_SIZE);
  }
  /* Was this page already instantiated by a forward reference to it? */
  if (pages[page_count].page_ref == NULL) {
    /* If not, create it. */
    pages[page_count].page_dict = pdf_new_dict ();
    /* and reference it */
    pages[page_count].page_ref = pdf_ref_obj(pages[page_count].page_dict);
  }
  pdf_add_dict (pages[page_count].page_dict,
              pdf_link_obj(type_name), pdf_link_obj(page_name));
  /* start the contents stream for the new page */
  this_page_contents = pdf_new_stream(STREAM_COMPRESS);
  start_current_page_resources();
  pdf_add_dict (pages[page_count].page_dict,
              pdf_link_obj (resources_name),
              pdf_ref_obj (current_page_resources));
  /* Contents are still available as this_page_contents until next
     page is started */
  /* Even though the page is gone, a Reference to this page is kept
     until program ends */
#ifdef MEM_DEBUG
MEM_END
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 953 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 925 of file pdfdoc.c.

{
  return page_tree;
}

Here is the caller graph for this function:

Definition at line 945 of file pdfdoc.c.

{
  if (page_count < 1) {
    ERROR ("Reference to previous page, but no pages have been completed yet");
  }
  return pdf_doc_ref_page(page_count>0?page_count:1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pdf_obj* pdf_doc_ref_page ( unsigned long  page_no)

Definition at line 901 of file pdfdoc.c.

{
  if (debug)
    fprintf (stderr, "(doc_ref_page:page_no=%ld)", page_no);
  if (page_no >= max_pages) {
    resize_pages (page_no+PAGES_ALLOC_SIZE);
  }
  /* Has this page been referenced yet? */ 
  if (pages[page_no-1].page_dict == NULL) {
    /* If not, create it */
    pages[page_no-1].page_dict = pdf_new_dict ();
    /* and reference it */
    pages[page_no-1].page_ref = pdf_ref_obj (pages[page_no-1].page_dict);
  }
  if (page_no > highest_page_ref)
    highest_page_ref = page_no;
  return pdf_link_obj (pages[page_no-1].page_ref);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1227 of file pdfdoc.c.

{
  breaking_state.llx = dev_page_width();
  breaking_state.urx = 0;
  breaking_state.lly = dev_page_height();
  breaking_state.ury = 0;
  breaking_state.dirty = 0;
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 92 of file pdfdoc.c.

{
  debug = 1;
}
void pdf_doc_set_origin ( double  x,
double  y 
)

Definition at line 191 of file pdfdoc.c.

{
  int len;
  static char first = 1;
  if (first) {
    sprintf (work_buffer, "%g 0 0 %g %g %g cm\n",
            dvi_tell_mag()*pdf_dev_scale(), dvi_tell_mag()*pdf_dev_scale(),
            x, y);
    len = strlen (work_buffer);
    pdf_add_stream (coord_xform_stream, work_buffer, len);
    first = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 86 of file pdfdoc.c.

{
  if (verbose < 255) 
    verbose += 1;
}

Here is the caller graph for this function:

void pdf_doc_start_article ( char *  name,
pdf_obj info 
)

Definition at line 702 of file pdfdoc.c.

{
  if (number_articles >= MAX_ARTICLES) {
    ERROR ("pdf_doc_add_article:  Too many articles\n");
  }
  if (name == NULL || strlen (name) == 0)
    ERROR ("pdf_doc_start_article called null name");
  articles[number_articles].name = NEW (strlen(name)+1, char);
  strcpy (articles[number_articles].name, name);
  articles[number_articles].info = info;
  articles[number_articles].first = NULL;
  articles[number_articles].last = NULL;
  /* Start dictionary for this article even though we can't finish it
     until we get the first bead */
  articles[number_articles].this = pdf_new_dict();
  number_articles++;
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf_doc_this_bop ( char *  string,
unsigned  length 
)

Definition at line 183 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 935 of file pdfdoc.c.

{
  return pages[page_count].page_dict;
}

Here is the caller graph for this function:

Definition at line 940 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void release_short_cuts ( void  ) [static]

Definition at line 138 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void resize_pages ( unsigned long  newsize) [static]

Definition at line 97 of file pdfdoc.c.

{
  unsigned long i;
  if (newsize > max_pages) {
    pages = RENEW (pages, newsize, struct pages);
    for (i=max_pages; i<newsize; i++) {
      pages[i].page_dict = NULL;
      pages[i].page_ref = NULL;
    }
    max_pages = newsize;
  }
}

Here is the caller graph for this function:

static void start_articles ( void  ) [static]

Definition at line 697 of file pdfdoc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void start_current_page_resources ( void  ) [static]

Definition at line 318 of file pdfdoc.c.

{
  /* work on resources to put in Pages */
  if (debug) {
    fprintf (stderr, "(start_current_page_resources)");
  }
  current_page_resources = pdf_new_dict ();
  tmp1 = pdf_new_array ();
  pdf_add_array (tmp1, pdf_new_name ("PDF"));
  pdf_add_array (tmp1, pdf_new_name ("Text"));
  pdf_add_array (tmp1, pdf_new_name ("ImageC"));
  pdf_add_dict (current_page_resources,
              pdf_new_name ("ProcSet"),
              tmp1);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void start_name_tree ( void  ) [static]

Definition at line 225 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(start_name_tree)");
  }
  names_dict = pdf_new_dict ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void start_outline_tree ( void  ) [static]

Definition at line 212 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(start_outline_tree)");
  }
  /* Create empty outline tree */
  outline[outline_depth].entry = pdf_new_dict();
  outline[outline_depth].kid_count = 0;
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void start_page_tree ( void  ) [static]

Definition at line 156 of file pdfdoc.c.

{
  if (debug) {
    fprintf (stderr, "(start_page_tree)");
  }
  /* Create empty page tree */
  page_tree = pdf_new_dict();
  page_tree_ref = pdf_ref_obj (page_tree);
  /* Both page_tree and page_tree_ref are kept open until the
     document is closed.  This allows the user to write to page_tree
     if he so choses. */
  /* Link /Pages into the catalog
     and poing it to indirect reference since we
     haven't built the tree yet */
  glob_page_bop = pdf_new_stream(0);
  glob_page_eop = pdf_new_stream(0);
  coord_xform_stream = pdf_new_stream(0);
  coord_xform_ref = pdf_ref_obj (coord_xform_stream);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

pdf_obj * annots_name [static]

Definition at line 110 of file pdfdoc.c.

Definition at line 696 of file pdfdoc.c.

pdf_obj * bead_name [static]

Definition at line 110 of file pdfdoc.c.

struct { ... } breaking_state [static]
pdf_obj* catalog = NULL [static]

Definition at line 46 of file pdfdoc.c.

pdf_obj * contents_name [static]

Definition at line 110 of file pdfdoc.c.

Definition at line 61 of file pdfdoc.c.

Definition at line 61 of file pdfdoc.c.

pdf_obj * count_name [static]

Definition at line 110 of file pdfdoc.c.

Definition at line 58 of file pdfdoc.c.

unsigned char debug = 0 [static]

Definition at line 84 of file pdfdoc.c.

pdf_obj* docinfo = NULL [static]

Definition at line 47 of file pdfdoc.c.

Definition at line 60 of file pdfdoc.c.

pdf_obj * glob_page_eop [static]

Definition at line 60 of file pdfdoc.c.

int highest_page_ref = 0 [static]

Definition at line 900 of file pdfdoc.c.

pdf_obj * kids_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj * limits_name [static]

Definition at line 110 of file pdfdoc.c.

unsigned long max_dests = 0

Definition at line 589 of file pdfdoc.c.

unsigned long max_pages = 0 [static]

Definition at line 73 of file pdfdoc.c.

pdf_obj * mediabox_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj* names_dict [static]

Definition at line 223 of file pdfdoc.c.

unsigned long number_articles = 0 [static]

Definition at line 694 of file pdfdoc.c.

unsigned long number_dests = 0 [static]

Definition at line 644 of file pdfdoc.c.

struct { ... } outline[MAX_OUTLINE_DEPTH] [static]

Definition at line 50 of file pdfdoc.c.

unsigned long page_count = 0 [static]

Definition at line 68 of file pdfdoc.c.

pdf_obj * page_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj* page_tree = NULL [static]

Definition at line 48 of file pdfdoc.c.

pdf_obj * page_tree_ref = NULL [static]

Definition at line 48 of file pdfdoc.c.

struct pages * pages [static]
pdf_obj * pages_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj * parent_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj * resources_name [static]

Definition at line 110 of file pdfdoc.c.

Definition at line 64 of file pdfdoc.c.

Definition at line 63 of file pdfdoc.c.

pdf_obj* this_page_bop = NULL [static]

Definition at line 62 of file pdfdoc.c.

Definition at line 59 of file pdfdoc.c.

Definition at line 65 of file pdfdoc.c.

Definition at line 65 of file pdfdoc.c.

pdf_obj * thumb_name [static]

Definition at line 110 of file pdfdoc.c.

pdf_obj* tmp1 [static]

Definition at line 66 of file pdfdoc.c.

pdf_obj* type_name [static]

Definition at line 110 of file pdfdoc.c.

unsigned char verbose = 0 [static]

Definition at line 84 of file pdfdoc.c.

int xobjects_pending = 0 [static]

Definition at line 1125 of file pdfdoc.c.