Changeset 134 for trunk/poppler


Ignore:
Timestamp:
Sep 29, 2006, 4:52:37 PM (15 years ago)
Author:
Eugene Romanenko
Message:

poppler updated to version 0.5.4

Location:
trunk/poppler/mypoppler
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/config.h

    r31 r134  
    154154/* Define for large files, on AIX-style hosts. */
    155155#undef _LARGE_FILES
     156
     157#define POPPLER_DATADIR "."
  • trunk/poppler/mypoppler/goo/gfile.cc

    r2 r134  
    589589#elif defined(WIN32)
    590590  int fa;
    591   GooString *s;
    592591#elif defined(ACORN)
    593592#else
    594593  struct stat st;
    595   GooString *s;
    596594#endif
    597595
    598596  name = new GooString(nameA);
    599597  dir = gFalse;
     598  fullPath = new GooString(dirPath);
     599  appendToPath(fullPath, nameA);
    600600  if (doStat) {
    601601#ifdef VMS
     
    605605#elif defined(ACORN)
    606606#else
    607     s = new GooString(dirPath);
    608     appendToPath(s, nameA);
    609607#ifdef WIN32
    610     fa = GetFileAttributes(s->getCString());
     608    fa = GetFileAttributes(fullPath->getCString());
    611609    dir = (fa != 0xFFFFFFFF && (fa & FILE_ATTRIBUTE_DIRECTORY));
    612610#else
    613     if (stat(s->getCString(), &st) == 0)
     611    if (stat(fullPath->getCString(), &st) == 0)
    614612      dir = S_ISDIR(st.st_mode);
    615613#endif
    616     delete s;
    617614#endif
    618615  }
     
    620617
    621618GDirEntry::~GDirEntry() {
     619  delete fullPath;
    622620  delete name;
    623621}
     
    691689  e = NULL;
    692690  if (dir) {
    693     ent = readdir(dir);
    694     if (ent && !strcmp(ent->d_name, ".")) {
     691    do {
    695692      ent = readdir(dir);
    696693    }
     694    while (ent && (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")));
    697695    if (ent) {
    698696      e = new GDirEntry(path->getCString(), ent->d_name, doStat);
  • trunk/poppler/mypoppler/goo/gfile.h

    r2 r134  
    108108  ~GDirEntry();
    109109  GooString *getName() { return name; }
     110  GooString *getFullPath() { return fullPath; }
    110111  GBool isDir() { return dir; }
    111112
     
    113114
    114115  GooString *name;              // dir/file name
     116  GooString *fullPath;
    115117  GBool dir;                    // is it a directory?
    116118};
  • trunk/poppler/mypoppler/poppler/CairoOutputDev.cc

    r44 r134  
    5959  textClipPath = NULL;
    6060  cairo = NULL;
     61  currentFont = NULL;
    6162}
    6263
     
    125126}
    126127
     128void CairoOutputDev::setDefaultCTM(double *ctm) {
     129  cairo_matrix_t matrix;
     130  matrix.xx = ctm[0];
     131  matrix.yx = ctm[1];
     132  matrix.xy = ctm[2];
     133  matrix.yy = ctm[3];
     134  matrix.x0 = ctm[4];
     135  matrix.y0 = ctm[5];
     136
     137  cairo_set_matrix (cairo, &matrix);
     138
     139  OutputDev::setDefaultCTM(ctm);
     140}
     141
    127142void CairoOutputDev::updateCTM(GfxState *state, double m11, double m12,
    128143                                double m21, double m22,
    129144                                double m31, double m32) {
     145  cairo_matrix_t matrix;
     146  matrix.xx = m11;
     147  matrix.yx = m12;
     148  matrix.xy = m21;
     149  matrix.yy = m22;
     150  matrix.x0 = m31;
     151  matrix.y0 = m32;
     152
     153  cairo_transform (cairo, &matrix);
    130154  updateLineDash(state);
    131155  updateLineJoin(state);
     
    138162  int dashLength;
    139163  double dashStart;
    140   double *transformedDash;
    141   double transformedStart;
    142   int i;
    143164
    144165  state->getLineDash(&dashPattern, &dashLength, &dashStart);
    145 
    146   transformedDash = new double[dashLength];
    147  
    148   for (i = 0; i < dashLength; ++i) {
    149     transformedDash[i] =  state->transformWidth(dashPattern[i]);
    150   }
    151   transformedStart = state->transformWidth(dashStart);
    152   cairo_set_dash (cairo, transformedDash, dashLength, transformedStart);
    153   delete [] transformedDash;
     166  cairo_set_dash (cairo, dashPattern, dashLength, dashStart);
    154167}
    155168
     
    191204
    192205void CairoOutputDev::updateLineWidth(GfxState *state) {
    193   LOG(printf ("line width: %f\n", state->getTransformedLineWidth()));
    194   if (state->getTransformedLineWidth() == 0.0) {
     206  LOG(printf ("line width: %f\n", state->getLineWidth()));
     207  if (state->getLineWidth() == 0.0) {
    195208      cairo_set_line_width (cairo, 72.0/300.0);
    196209  } else {
    197       cairo_set_line_width (cairo, state->getTransformedLineWidth());
     210      cairo_set_line_width (cairo, state->getLineWidth());
    198211  }
    199212}
     
    274287  font_face = currentFont->getFontFace();
    275288  cairo_set_font_face (cairo, font_face);
    276 
    277   matrix.xx = m11;
    278   matrix.xy = -m21;
    279   matrix.yx = m12;
    280   matrix.yy = -m22;
     289 
     290  double fontSize = state->getFontSize();
     291  double *m = state->getTextMat();
     292  matrix.xx = m[0] * fontSize;
     293  matrix.yx = m[1] * fontSize;
     294  matrix.xy = -m[2] * fontSize;
     295  matrix.yy = -m[3] * fontSize;
    281296  matrix.x0 = 0;
    282297  matrix.y0 = 0;
     
    286301void CairoOutputDev::doPath(GfxState *state, GfxPath *path) {
    287302  GfxSubpath *subpath;
    288   double x1, y1, x2, y2, x3, y3;
    289303  int i, j;
    290 
    291304  for (i = 0; i < path->getNumSubpaths(); ++i) {
    292305    subpath = path->getSubpath(i);
    293306    if (subpath->getNumPoints() > 0) {
    294       state->transform(subpath->getX(0), subpath->getY(0), &x1, &y1);
    295       cairo_move_to (cairo, x1, y1);
    296       LOG (printf ("move_to %f, %f\n", x1, y1));
    297       j = 1;
     307      cairo_move_to (cairo, subpath->getX(0), subpath->getY(0));
     308         j = 1;
    298309      while (j < subpath->getNumPoints()) {
    299310        if (subpath->getCurve(j)) {
    300           state->transform(subpath->getX(j), subpath->getY(j), &x1, &y1);
    301           state->transform(subpath->getX(j+1), subpath->getY(j+1), &x2, &y2);
    302           state->transform(subpath->getX(j+2), subpath->getY(j+2), &x3, &y3);
    303           cairo_curve_to (cairo,
    304                           x1, y1,
    305                           x2, y2,
    306                           x3, y3);
    307           LOG (printf ("curve_to %f, %f  %f, %f  %f, %f\n", x1, y1, x2, y2, x3, y3));
     311          cairo_curve_to( cairo,
     312                          subpath->getX(j), subpath->getY(j),
     313                          subpath->getX(j+1), subpath->getY(j+1),
     314                          subpath->getX(j+2), subpath->getY(j+2));
     315
    308316          j += 3;
    309317        } else {
    310           state->transform(subpath->getX(j), subpath->getY(j), &x1, &y1);
    311           cairo_line_to (cairo, x1, y1);
    312           LOG(printf ("line_to %f, %f\n", x1, y1));
     318          cairo_line_to (cairo, subpath->getX(j), subpath->getY(j));
    313319          ++j;
    314320        }
     
    375381                              CharCode code, int nBytes, Unicode *u, int uLen)
    376382{
    377   double tx, ty;
    378 
    379383  if (!currentFont)
    380384    return;
    381385 
    382386  glyphs[glyphCount].index = currentFont->getGlyph (code, u, uLen);
    383   state->transform(x - originX, y - originY, &tx, &ty);
    384   glyphs[glyphCount].x = tx;
    385   glyphs[glyphCount].y = ty;
     387  glyphs[glyphCount].x = x - originX;
     388  glyphs[glyphCount].y = y - originY;
    386389  glyphCount++;
    387390}
     
    393396  if (!currentFont)
    394397    return;
    395    
     398
     399  // endString can be called without a corresponding beginString. If this
     400  // happens glyphs will be null so don't draw anything, just return.
     401  // XXX: OutputDevs should probably not have to deal with this...
     402  if (!glyphs)
     403    return;
     404
    396405  // ignore empty strings and invisible text -- this is used by
    397406  // Acrobat Capture
     
    436445    cairo_new_path (cairo);
    437446  }
    438  
     447
    439448  gfree (glyphs);
    440449  glyphs = NULL;
     
    444453                                      double dx, double dy,
    445454                                      CharCode code, Unicode *u, int uLen) {
     455
     456  cairo_save (cairo);
     457  double *ctm;
     458  cairo_matrix_t matrix;
     459
     460  ctm = state->getCTM();
     461  matrix.xx = ctm[0];
     462  matrix.yx = ctm[1];
     463  matrix.xy = ctm[2];
     464  matrix.yy = ctm[3];
     465  matrix.x0 = ctm[4];
     466  matrix.y0 = ctm[5];
     467  cairo_set_matrix(cairo, &matrix);
    446468  return gFalse;
    447469}
    448470
    449471void CairoOutputDev::endType3Char(GfxState *state) {
     472  cairo_restore (cairo);
    450473}
    451474
     
    479502  ImageStream *imgStr;
    480503  Guchar *pix;
    481   double *ctm;
    482504  cairo_matrix_t matrix;
    483505  int invert_bit;
    484506  int row_stride;
    485507
    486   ctm = state->getCTM();
    487   LOG (printf ("drawImageMask %dx%d, matrix: %f, %f, %f, %f, %f, %f\n",
    488                width, height, ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]));
    489   matrix.xx = ctm[0] / width;
    490   matrix.xy = -ctm[2] / height;
    491   matrix.yx = ctm[1] / width;
    492   matrix.yy = -ctm[3] / height;
    493   matrix.x0 = ctm[2] + ctm[4];
    494   matrix.y0 = ctm[3] + ctm[5];
     508  /* FIXME: Doesn't the image mask support any colorspace? */
     509  cairo_set_source (cairo, fill_pattern);
    495510
    496511  /* work around a cairo bug when scaling 1x1 surfaces */
    497512  if (width == 1 && height == 1) {
    498513    cairo_save (cairo);
    499     cairo_set_matrix (cairo, &matrix);
    500     cairo_rectangle (cairo, 0., 0., 1., 1.);
     514    cairo_rectangle (cairo, 0., 0., width, height);
    501515    cairo_fill (cairo);
    502516    cairo_restore (cairo);
     
    541555  }
    542556
    543   cairo_matrix_invert (&matrix);
     557  cairo_matrix_init_translate (&matrix, 0, height);
     558  cairo_matrix_scale (&matrix, width, -height);
     559
    544560  cairo_pattern_set_matrix (pattern, &matrix);
    545561
     
    549565  cairo_pattern_set_filter (pattern, CAIRO_FILTER_BEST);
    550566
    551   /* FIXME: Doesn't the image mask support any colorspace? */
    552   cairo_set_source (cairo, fill_pattern);
    553567  cairo_mask (cairo, pattern);
    554568
     
    606620  GfxRGB rgb;
    607621  int alpha, i;
    608   double *ctm;
    609622  cairo_matrix_t matrix;
    610623  cairo_matrix_t maskMatrix;
     
    645658  }
    646659
    647   ctm = state->getCTM();
    648   LOG (printf ("drawImageMask %dx%d, matrix: %f, %f, %f, %f, %f, %f\n",
    649                width, height, ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]));
    650   matrix.xx = ctm[0] / width;
    651   matrix.xy = -ctm[2] / height;
    652   matrix.yx = ctm[1] / width;
    653   matrix.yy = -ctm[3] / height;
    654   matrix.x0 = ctm[2] + ctm[4];
    655   matrix.y0 = ctm[3] + ctm[5];
    656 
    657   maskMatrix.xx = ctm[0] / maskWidth;
    658   maskMatrix.xy = -ctm[2] / maskHeight;
    659   maskMatrix.yx = ctm[1] / maskWidth;
    660   maskMatrix.yy = -ctm[3] / maskHeight;
    661   maskMatrix.x0 = ctm[2] + ctm[4];
    662   maskMatrix.y0 = ctm[3] + ctm[5];
    663 
    664   cairo_matrix_invert (&matrix);
    665   cairo_matrix_invert (&maskMatrix);
     660  LOG (printf ("drawMaskedImage %dx%d\n", width, height));
     661
     662  cairo_matrix_init_translate (&matrix, 0, height);
     663  cairo_matrix_scale (&matrix, width, -height);
     664
     665  cairo_matrix_init_translate (&maskMatrix, 0, maskHeight);
     666  cairo_matrix_scale (&maskMatrix, maskWidth, -maskHeight);
     667
    666668
    667669  cairo_pattern_set_matrix (pattern, &matrix);
     
    721723  GfxRGB rgb;
    722724  int alpha, i;
    723   double *ctm;
    724725  cairo_matrix_t matrix;
    725726  cairo_matrix_t maskMatrix;
     
    760761  }
    761762
    762   ctm = state->getCTM();
    763   LOG (printf ("drawImageMask %dx%d, matrix: %f, %f, %f, %f, %f, %f\n",
    764                width, height, ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]));
    765   matrix.xx = ctm[0] / width;
    766   matrix.xy = -ctm[2] / height;
    767   matrix.yx = ctm[1] / width;
    768   matrix.yy = -ctm[3] / height;
    769   matrix.x0 = ctm[2] + ctm[4];
    770   matrix.y0 = ctm[3] + ctm[5];
    771 
    772   maskMatrix.xx = ctm[0] / maskWidth;
    773   maskMatrix.xy = -ctm[2] / maskHeight;
    774   maskMatrix.yx = ctm[1] / maskWidth;
    775   maskMatrix.yy = -ctm[3] / maskHeight;
    776   maskMatrix.x0 = ctm[2] + ctm[4];
    777   maskMatrix.y0 = ctm[3] + ctm[5];
    778 
    779   cairo_matrix_invert (&matrix);
    780   cairo_matrix_invert (&maskMatrix);
     763  LOG (printf ("drawSoftMaskedImage %dx%d\n", width, height));
     764
     765  cairo_matrix_init_translate (&matrix, 0, height);
     766  cairo_matrix_scale (&matrix, width, -height);
     767
     768  cairo_matrix_init_translate (&maskMatrix, 0, maskHeight);
     769  cairo_matrix_scale (&maskMatrix, maskWidth, -maskHeight);
    781770
    782771  cairo_pattern_set_matrix (pattern, &matrix);
     
    809798  GfxRGB rgb;
    810799  int alpha, i;
    811   double *ctm;
    812800  cairo_matrix_t matrix;
    813801  int is_identity_transform;
     
    871859  }
    872860
    873   ctm = state->getCTM();
    874   LOG (printf ("drawImageMask %dx%d, matrix: %f, %f, %f, %f, %f, %f\n",
    875                width, height, ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]));
    876   matrix.xx = ctm[0] / width;
    877   matrix.xy = -ctm[2] / height;
    878   matrix.yx = ctm[1] / width;
    879   matrix.yy = -ctm[3] / height;
    880   matrix.x0 = ctm[2] + ctm[4];
    881   matrix.y0 = ctm[3] + ctm[5];
    882 
    883   cairo_matrix_invert (&matrix);
     861  LOG (printf ("drawImageMask %dx%d\n", width, height));
     862 
     863  cairo_matrix_init_translate (&matrix, 0, height);
     864  cairo_matrix_scale (&matrix, width, -height);
     865
    884866  cairo_pattern_set_matrix (pattern, &matrix);
    885867
  • trunk/poppler/mypoppler/poppler/CairoOutputDev.h

    r44 r134  
    7272  //----- update graphics state
    7373  virtual void updateAll(GfxState *state);
     74  virtual void setDefaultCTM(double *ctm);
    7475  virtual void updateCTM(GfxState *state, double m11, double m12,
    7576                         double m21, double m22, double m31, double m32);
  • trunk/poppler/mypoppler/poppler/Catalog.cc

    r27 r134  
    441441NameTree::Entry::Entry(Array *array, int index) {
    442442    GooString n;
    443     if (!array->getString(index, &n) || !array->getNF(index + 1, &value))
    444         error(-1, "Invalid page tree");
     443    if (!array->getString(index, &n) || !array->getNF(index + 1, &value)) {
     444      Object aux;
     445      array->get(index, &aux);
     446      if (aux.isString() && array->getNF(index + 1, &value) )
     447      {
     448        n.append(aux.getString());
     449      }
     450      else
     451        error(-1, "Invalid page tree");
     452    }
    445453    name = new UGooString(n);
    446454}
     
    488496    }
    489497  }
     498  names.free();
    490499
    491500  // root or intermediate node
  • trunk/poppler/mypoppler/poppler/DCTStream.cc

    r2 r134  
    5555DCTStream::DCTStream(Stream *strA):
    5656  FilterStream(strA) {
    57  
     57  init();
     58}
     59
     60DCTStream::~DCTStream() {
     61  jpeg_destroy_decompress(&cinfo);
     62  delete str;
     63}
     64
     65void DCTStream::init()
     66{
    5867  jpeg_create_decompress(&cinfo);
    5968  src.pub.init_source = str_init_source;
     
    6978  cinfo.err = jpeg_std_error(&jerr);
    7079  x = 0;
    71 }
    72 
    73 DCTStream::~DCTStream() {
    74   jpeg_destroy_decompress(&cinfo);
    75   delete str;
     80  row_buffer = NULL;
    7681}
    7782
     
    8085
    8186  str->reset();
    82  
     87
     88  if (row_buffer)
     89  {
     90    jpeg_destroy_decompress(&cinfo);
     91    init();
     92  }
     93
    8394  // JPEG data has to start with 0xFF 0xD8
    8495  // but some pdf like the one on
  • trunk/poppler/mypoppler/poppler/DCTStream.h

    r2 r134  
    6262
    6363private:
     64  void init();
     65
    6466  unsigned int x;
    6567  struct jpeg_decompress_struct cinfo;
  • trunk/poppler/mypoppler/poppler/Dict.cc

    r2 r134  
    4242}
    4343
    44 void Dict::add(const UGooString &key, Object *val) {
     44void Dict::addOwnKeyVal(UGooString *key, Object *val) {
    4545  if (length == size) {
    4646    if (length == 0) {
     
    5151    entries = (DictEntry *)greallocn(entries, size, sizeof(DictEntry));
    5252  }
    53   entries[length].key = new UGooString(key);
     53  entries[length].key = key;
    5454  entries[length].val = *val;
    5555  ++length;
  • trunk/poppler/mypoppler/poppler/Dict.h

    r2 r134  
    1515
    1616#include "Object.h"
     17#include "UGooString.h"
    1718
    18 class UGooString;
    1919//------------------------------------------------------------------------
    2020// Dict
     
    4343
    4444  // Add an entry
    45   void add(const UGooString &key, Object *val);
     45  void addOwnKeyVal(UGooString *key, Object *val);
     46  // FIXME: should also be renamed to addOwnVal()
     47  void add(const UGooString &key, Object *val) {
     48    addOwnKeyVal(new UGooString(key), val);
     49  }
     50  void addOwnVal(const char *key, Object *val) {
     51    addOwnKeyVal(new UGooString(key), val);
     52  }
    4653
    4754  // Check if dictionary is of specified type.
  • trunk/poppler/mypoppler/poppler/FlateStream.cc

    r2 r134  
    1717  out_pos = 0;
    1818  memset(&d_stream, 0, sizeof(d_stream));
     19  inflateInit(&d_stream);
    1920}
    2021
     
    2829  //FIXME: what are the semantics of reset?
    2930  //i.e. how much intialization has to happen in the constructor?
    30   str->reset();
     31
     32  /* reinitialize zlib */
     33  inflateEnd(&d_stream);
    3134  memset(&d_stream, 0, sizeof(d_stream));
    3235  inflateInit(&d_stream);
     36
     37  str->reset();
    3338  d_stream.avail_in = 0;
    3439  status = Z_OK;
     
    6267
    6368int FlateStream::fill_buffer() {
     69  /* only fill the buffer if it has all been used */
    6470  if (out_pos >= out_buf_len) {
     71    /* check if the flatestream has been exhausted */
    6572    if (status == Z_STREAM_END) {
    6673      return -1;
    6774    }
     75
     76    /* set to the begining of out_buf */
    6877    d_stream.avail_out = sizeof(out_buf);
    6978    d_stream.next_out = out_buf;
    7079    out_pos = 0;
    71     /* buffer is empty so we need to fill it */
    72     if (d_stream.avail_in == 0) {
    73       int c;
    74       /* read from the source stream */
    75       while (d_stream.avail_in < sizeof(in_buf) && (c = str->getChar()) != EOF) {
    76         in_buf[d_stream.avail_in++] = c;
     80
     81    while (1) {
     82      /* buffer is empty so we need to fill it */
     83      if (d_stream.avail_in == 0) {
     84        int c;
     85        /* read from the source stream */
     86        while (d_stream.avail_in < sizeof(in_buf) && (c = str->getChar()) != EOF) {
     87          in_buf[d_stream.avail_in++] = c;
     88        }
     89        d_stream.next_in = in_buf;
    7790      }
    78       d_stream.next_in = in_buf;
    79     }
    80     while (d_stream.avail_out && d_stream.avail_in && (status == Z_OK || status == Z_BUF_ERROR)) {
     91
     92      /* keep decompressing until we can't anymore */
     93      if (d_stream.avail_out == 0 || d_stream.avail_in == 0 || (status != Z_OK && status != Z_BUF_ERROR))
     94        break;
    8195      status = inflate(&d_stream, Z_SYNC_FLUSH);
    8296    }
     97
    8398    out_buf_len = sizeof(out_buf) - d_stream.avail_out;
    8499    if (status != Z_OK && status != Z_STREAM_END)
  • trunk/poppler/mypoppler/poppler/FlateStream.h

    r2 r134  
    5858  StreamPredictor *pred;
    5959  int status;
    60   unsigned char in_buf[4096];
     60  /* in_buf currently needs to be 1 or we over read from EmbedStreams */
     61  unsigned char in_buf[1];
    6162  unsigned char out_buf[4096];
    6263  int out_pos;
  • trunk/poppler/mypoppler/poppler/Gfx.cc

    r27 r134  
    484484  out = outA;
    485485  state = new GfxState(72, 72, box, 0, gFalse);
    486   out->updateAll(state);
    487486  fontChanged = gFalse;
    488487  clip = clipNone;
     
    12131212    return;
    12141213  }
     1214  state->closePath();
    12151215  if (state->isPath()) {
    1216     state->closePath();
    12171216    out->stroke(state);
    12181217  }
  • trunk/poppler/mypoppler/poppler/GfxState.cc

    r27 r134  
    6363//------------------------------------------------------------------------
    6464
    65 static struct {
    66  char *name;
    67  GfxBlendMode mode;
    68 } gfxBlendModeNames[] = {
     65struct gfxBlendModeName {
     66  char *name;
     67  GfxBlendMode mode;
     68};
     69
     70static gfxBlendModeName gfxBlendModeNames[] = {
    6971  { "Normal",     gfxBlendNormal },
    7072  { "Compatible", gfxBlendNormal },
     
    8789
    8890#define nGfxBlendModeNames \
    89           ((int)((sizeof(gfxBlendModeNames) / sizeof(char *))))
     91          ((int)((sizeof(gfxBlendModeNames) / sizeof(gfxBlendModeName))))
    9092         
    9193//------------------------------------------------------------------------
     
    33703372 err1:
    33713373  ok = gFalse;
     3374  for (k = 0; k < gfxColorMaxComps; ++k) {
     3375    lookup[k] = NULL;
     3376  }
     3377  byte_lookup = NULL;
    33723378}
    33733379
  • trunk/poppler/mypoppler/poppler/GlobalParams.cc

    r2 r134  
    437437    fclose(f);
    438438  }
     439
     440  scanEncodingDirs();
    439441}
    440442
     
    486488        }
    487489      } else if (!cmd->cmp("nameToUnicode")) {
    488         parseNameToUnicode(tokens, fileName, line);
     490        if (tokens->getLength() != 2)
     491          error(-1, "Bad 'nameToUnicode' config file command (%s:%d)",
     492                fileName->getCString(), line);
     493        else
     494          parseNameToUnicode((GooString *) tokens->get(1));
    489495      } else if (!cmd->cmp("cidToUnicode")) {
    490496        parseCIDToUnicode(tokens, fileName, line);
     
    604610}
    605611
    606 void GlobalParams::parseNameToUnicode(GooList *tokens, GooString *fileName,
    607                                          int line) {
    608   GooString *name;
     612void GlobalParams::scanEncodingDirs() {
     613  GDir *dir;
     614  GDirEntry *entry;
     615
     616  dir = new GDir(POPPLER_DATADIR "/nameToUnicode", gFalse);
     617  while (entry = dir->getNextEntry(), entry != NULL) {
     618    parseNameToUnicode(entry->getFullPath());
     619    delete entry;
     620  }
     621  delete dir;
     622
     623  dir = new GDir(POPPLER_DATADIR "/cidToUnicode", gFalse);
     624  while (entry = dir->getNextEntry(), entry != NULL) {
     625    addCIDToUnicode(entry->getName(), entry->getFullPath());
     626    delete entry;
     627  }
     628  delete dir;
     629
     630  dir = new GDir(POPPLER_DATADIR "/unicodeMap", gFalse);
     631  while (entry = dir->getNextEntry(), entry != NULL) {
     632    addUnicodeMap(entry->getName(), entry->getFullPath());
     633    delete entry;
     634  }
     635  delete dir;
     636
     637  dir = new GDir(POPPLER_DATADIR "/cMap", gFalse);
     638  while (entry = dir->getNextEntry(), entry != NULL) {
     639    addCMapDir(entry->getName(), entry->getFullPath());
     640    toUnicodeDirs->append(entry->getFullPath()->copy());
     641    delete entry;
     642  }
     643  delete dir;
     644}
     645
     646void GlobalParams::parseNameToUnicode(GooString *name) {
    609647  char *tok1, *tok2;
    610648  FILE *f;
    611649  char buf[256];
    612   int line2;
     650  int line;
    613651  Unicode u;
    614652
    615   if (tokens->getLength() != 2) {
    616     error(-1, "Bad 'nameToUnicode' config file command (%s:%d)",
    617           fileName->getCString(), line);
    618     return;
    619   }
    620   name = (GooString *)tokens->get(1);
    621653  if (!(f = fopen(name->getCString(), "r"))) {
    622654    error(-1, "Couldn't open 'nameToUnicode' file '%s'",
     
    624656    return;
    625657  }
    626   line2 = 1;
     658  line = 1;
    627659  while (getLine(buf, sizeof(buf), f)) {
    628660    tok1 = strtok(buf, " \t\r\n");
     
    633665    } else {
    634666      error(-1, "Bad line in 'nameToUnicode' file (%s:%d)",
    635             name->getCString(), line2);
    636     }
    637     ++line2;
     667            name->getCString(), line);
     668    }
     669    ++line;
    638670  }
    639671  fclose(f);
     672}
     673
     674void GlobalParams::addCIDToUnicode(GooString *collection,
     675                                   GooString *fileName) {
     676  GooString *old;
     677
     678  if ((old = (GooString *)cidToUnicodes->remove(collection))) {
     679    delete old;
     680  }
     681  cidToUnicodes->add(collection->copy(), fileName->copy());
    640682}
    641683
    642684void GlobalParams::parseCIDToUnicode(GooList *tokens, GooString *fileName,
    643685                                     int line) {
    644   GooString *collection, *name, *old;
    645 
    646686  if (tokens->getLength() != 3) {
    647687    error(-1, "Bad 'cidToUnicode' config file command (%s:%d)",
     
    649689    return;
    650690  }
    651   collection = (GooString *)tokens->get(1);
    652   name = (GooString *)tokens->get(2);
    653   if ((old = (GooString *)cidToUnicodes->remove(collection))) {
    654     delete old;
    655   }
    656   cidToUnicodes->add(collection->copy(), name->copy());
     691  addCIDToUnicode((GooString *)tokens->get(1), (GooString *)tokens->get(2));
    657692}
    658693
     
    674709}
    675710
     711void GlobalParams::addUnicodeMap(GooString *encodingName, GooString *fileName)
     712{
     713  GooString *old;
     714
     715  if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
     716    delete old;
     717  }
     718  unicodeMaps->add(encodingName->copy(), fileName->copy());
     719}
     720
    676721void GlobalParams::parseUnicodeMap(GooList *tokens, GooString *fileName,
    677722                                   int line) {
    678   GooString *encodingName, *name, *old;
    679723
    680724  if (tokens->getLength() != 3) {
     
    683727    return;
    684728  }
    685   encodingName = (GooString *)tokens->get(1);
    686   name = (GooString *)tokens->get(2);
    687   if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
    688     delete old;
    689   }
    690   unicodeMaps->add(encodingName->copy(), name->copy());
     729  addUnicodeMap((GooString *)tokens->get(1), (GooString *)tokens->get(2));
     730}
     731
     732void GlobalParams::addCMapDir(GooString *collection, GooString *dir) {
     733  GooList *list;
     734
     735  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
     736    list = new GooList();
     737    cMapDirs->add(collection->copy(), list);
     738  }
     739  list->append(dir->copy());
    691740}
    692741
    693742void GlobalParams::parseCMapDir(GooList *tokens, GooString *fileName, int line) {
    694   GooString *collection, *dir;
    695   GooList *list;
    696 
    697743  if (tokens->getLength() != 3) {
    698744    error(-1, "Bad 'cMapDir' config file command (%s:%d)",
     
    700746    return;
    701747  }
    702   collection = (GooString *)tokens->get(1);
    703   dir = (GooString *)tokens->get(2);
    704   if (!(list = (GooList *)cMapDirs->lookup(collection))) {
    705     list = new GooList();
    706     cMapDirs->add(collection->copy(), list);
    707   }
    708   list->append(dir->copy());
     748  addCMapDir((GooString *)tokens->get(1), (GooString *)tokens->get(2));
    709749}
    710750
  • trunk/poppler/mypoppler/poppler/GlobalParams.h

    r2 r134  
    221221
    222222  void parseFile(GooString *fileName, FILE *f);
    223   void parseNameToUnicode(GooList *tokens, GooString *fileName, int line);
     223  void parseNameToUnicode(GooString *name);
    224224  void parseCIDToUnicode(GooList *tokens, GooString *fileName, int line);
    225225  void parseUnicodeToUnicode(GooList *tokens, GooString *fileName, int line);
     
    244244  GBool parseYesNo2(char *token, GBool *flag);
    245245  UnicodeMap *getUnicodeMap2(GooString *encodingName);
     246
     247  void scanEncodingDirs();
     248  void addCIDToUnicode(GooString *collection, GooString *fileName);
     249  void addUnicodeMap(GooString *encodingName, GooString *fileName);
     250  void addCMapDir(GooString *collection, GooString *dir);
    246251
    247252  //----- static tables
  • trunk/poppler/mypoppler/poppler/Object.h

    r2 r134  
    108108  // Copy an object.
    109109  Object *copy(Object *obj);
     110  Object *shallowCopy(Object *obj) {
     111    *obj = *this;
     112    return obj;
     113  }
    110114
    111115  // If object is a Ref, fetch and return the referenced object.
     
    165169  // Dict accessors.
    166170  int dictGetLength();
     171  void dictAddOwnKeyVal(UGooString *key, Object *val);
    167172  void dictAdd(const UGooString &key, Object *val);
     173  void dictAddOwnVal(const char *key, Object *val);
    168174  GBool dictIs(char *dictType);
    169175  Object *dictLookup(const UGooString &key, Object *obj);
     
    243249  { dict->add(key, val); }
    244250
     251inline void Object::dictAddOwnVal(const char *key, Object *val)
     252  { dict->addOwnVal(key, val); }
     253
     254inline void Object::dictAddOwnKeyVal(UGooString *key, Object *val)
     255  { dict->addOwnKeyVal(key, val); }
     256
    245257inline GBool Object::dictIs(char *dictType)
    246258  { return dict->is(dictType); }
  • trunk/poppler/mypoppler/poppler/PSOutputDev.cc

    r91 r134  
    706706
    707707struct PSSubstFont {
    708   char *psName;         // PostScript name
    709   double mWidth;        // width of 'm' character
     708  char *psName;                 // PostScript name
     709  double mWidth;                // width of 'm' character
    710710};
    711711
     
    767767
    768768  PSOutCustomColor(double cA, double mA,
    769            double yA, double kA, GooString *nameA);
     769                   double yA, double kA, GooString *nameA);
    770770  ~PSOutCustomColor();
    771771
     
    776776
    777777PSOutCustomColor::PSOutCustomColor(double cA, double mA,
    778                    double yA, double kA, GooString *nameA) {
     778                                   double yA, double kA, GooString *nameA) {
    779779  c = cA;
    780780  m = mA;
     
    797797
    798798  DeviceNRecoder(Stream *strA, int widthA, int heightA,
    799         GfxImageColorMap *colorMapA);
     799                GfxImageColorMap *colorMapA);
    800800  virtual ~DeviceNRecoder();
    801801  virtual StreamKind getKind() { return strWeird; }
     
    824824
    825825DeviceNRecoder::DeviceNRecoder(Stream *strA, int widthA, int heightA,
    826                    GfxImageColorMap *colorMapA):
     826                               GfxImageColorMap *colorMapA):
    827827    FilterStream(strA) {
    828828  width = widthA;
     
    846846void DeviceNRecoder::reset() {
    847847  imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    848                colorMap->getBits());
     848                           colorMap->getBits());
    849849  imgStr->reset();
    850850}
     
    887887}
    888888
    889 PSOutputDev::PSOutputDev(char *fileName, XRef *xrefA, Catalog *catalog,
    890             int firstPage, int lastPage, PSOutMode modeA,
     889PSOutputDev::PSOutputDev(const char *fileName, XRef *xrefA, Catalog *catalog,
     890                        int firstPage, int lastPage, PSOutMode modeA,
    891891                         int paperWidthA, int paperHeightA, GBool duplexA,
    892             int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    893             GBool manualCtrlA) {
     892                        int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     893                        GBool manualCtrlA) {
    894894  FILE *f;
    895895  PSFileType fileTypeA;
     
    946946
    947947PSOutputDev::PSOutputDev(PSOutputFunc outputFuncA, void *outputStreamA,
    948             XRef *xrefA, Catalog *catalog,
    949             int firstPage, int lastPage, PSOutMode modeA,
     948                        XRef *xrefA, Catalog *catalog,
     949                        int firstPage, int lastPage, PSOutMode modeA,
    950950                         int paperWidthA, int paperHeightA, GBool duplexA,
    951             int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    952             GBool manualCtrlA) {
     951                        int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     952                        GBool manualCtrlA) {
    953953  underlayCbk = NULL;
    954954  underlayCbkData = NULL;
     
    973973
    974974void PSOutputDev::init(PSOutputFunc outputFuncA, void *outputStreamA,
    975                PSFileType fileTypeA, XRef *xrefA, Catalog *catalog,
    976                int firstPage, int lastPage, PSOutMode modeA,
    977                int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    978                GBool manualCtrlA, int paperWidthA, int paperHeightA,
     975                       PSFileType fileTypeA, XRef *xrefA, Catalog *catalog,
     976                       int firstPage, int lastPage, PSOutMode modeA,
     977                       int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     978                       GBool manualCtrlA, int paperWidthA, int paperHeightA,
    979979                       GBool duplexA) {
    980980  Page *page;
     
    10601060    if (firstPage > 0 && firstPage <= catalog->getNumPages()) {
    10611061      writeHeader(firstPage, lastPage,
    1062           catalog->getPage(firstPage)->getMediaBox(),
    1063           catalog->getPage(firstPage)->getCropBox(),
    1064           catalog->getPage(firstPage)->getRotate());
     1062                  catalog->getPage(firstPage)->getMediaBox(),
     1063                  catalog->getPage(firstPage)->getCropBox(),
     1064                  catalog->getPage(firstPage)->getRotate());
    10651065    } else {
    10661066      box = new PDFRectangle(0, 0, 1, 1);
     
    10951095      writeTrailer();
    10961096      if (mode != psModeForm) {
    1097     writePS("%%EOF\n");
     1097        writePS("%%EOF\n");
    10981098      }
    10991099    }
     
    11521152
    11531153void PSOutputDev::writeHeader(int firstPage, int lastPage,
    1154                   PDFRectangle *mediaBox, PDFRectangle *cropBox,
    1155                   int pageRotate) {
     1154                              PDFRectangle *mediaBox, PDFRectangle *cropBox,
     1155                              int pageRotate) {
    11561156  double x1, y1, x2, y2;
    11571157
     
    11611161    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    11621162    writePSFmt("%%%%LanguageLevel: %d\n",
    1163            (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1164            (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1163               (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1164               (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    11651165    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    11661166      writePS("%%DocumentProcessColors: (atend)\n");
     
    11691169    writePS("%%DocumentSuppliedResources: (atend)\n");
    11701170    writePSFmt("%%%%DocumentMedia: plain %d %d 0 () ()\n",
    1171            paperWidth, paperHeight);
     1171               paperWidth, paperHeight);
    11721172    writePSFmt("%%%%BoundingBox: 0 0 %d %d\n", paperWidth, paperHeight);
    11731173    writePSFmt("%%%%Pages: %d\n", lastPage - firstPage + 1);
     
    11811181    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    11821182    writePSFmt("%%%%LanguageLevel: %d\n",
    1183            (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1184            (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1183               (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1184               (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    11851185    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    11861186      writePS("%%DocumentProcessColors: (atend)\n");
     
    12031203    }
    12041204    writePSFmt("%%%%BoundingBox: %d %d %d %d\n",
    1205            (int)floor(x1), (int)floor(y1), (int)ceil(x2), (int)ceil(y2));
     1205               (int)floor(x1), (int)floor(y1), (int)ceil(x2), (int)ceil(y2));
    12061206    if (floor(x1) != ceil(x1) || floor(y1) != ceil(y1) ||
    1207     floor(x2) != ceil(x2) || floor(y2) != ceil(y2)) {
     1207        floor(x2) != ceil(x2) || floor(y2) != ceil(y2)) {
    12081208      writePSFmt("%%%%HiResBoundingBox: %g %g %g %g\n", x1, y1, x2, y2);
    12091209    }
     
    12151215    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    12161216    writePSFmt("%%%%LanguageLevel: %d\n",
    1217            (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1218            (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1217               (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1218               (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    12191219    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    12201220      writePS("%%DocumentProcessColors: (atend)\n");
     
    12251225    writePS("32 dict dup begin\n");
    12261226    writePSFmt("/BBox [%d %d %d %d] def\n",
    1227            (int)floor(mediaBox->x1), (int)floor(mediaBox->y1),
    1228            (int)ceil(mediaBox->x2), (int)ceil(mediaBox->y2));
     1227               (int)floor(mediaBox->x1), (int)floor(mediaBox->y1),
     1228               (int)ceil(mediaBox->x2), (int)ceil(mediaBox->y2));
    12291229    writePS("/FormType 1 def\n");
    12301230    writePS("/Matrix [1 0 0 1 0 0] def\n");
     
    12441244      lev1 = lev2 = lev3 = sep = nonSep = gFalse;
    12451245      for (q = *p + 1; *q; ++q) {
    1246     switch (*q) {
    1247     case '1': lev1 = gTrue; break;
    1248     case '2': lev2 = gTrue; break;
    1249     case '3': lev3 = gTrue; break;
    1250     case 's': sep = gTrue; break;
    1251     case 'n': nonSep = gTrue; break;
    1252     }
     1246        switch (*q) {
     1247        case '1': lev1 = gTrue; break;
     1248        case '2': lev2 = gTrue; break;
     1249        case '3': lev3 = gTrue; break;
     1250        case 's': sep = gTrue; break;
     1251        case 'n': nonSep = gTrue; break;
     1252        }
    12531253      }
    12541254    } else if ((level == psLevel1 && lev1 && nonSep) ||
    1255            (level == psLevel1Sep && lev1 && sep) ||
    1256            (level == psLevel2 && lev2 && nonSep) ||
    1257            (level == psLevel2Sep && lev2 && sep) ||
    1258            (level == psLevel3 && lev3 && nonSep) ||
    1259            (level == psLevel3Sep && lev3 && sep)) {
     1255               (level == psLevel1Sep && lev1 && sep) ||
     1256               (level == psLevel2 && lev2 && nonSep) ||
     1257               (level == psLevel2Sep && lev2 && sep) ||
     1258               (level == psLevel3 && lev3 && nonSep) ||
     1259               (level == psLevel3Sep && lev3 && sep)) {
    12601260      writePSFmt("%s\n", *p);
    12611261    }
     
    12711271
    12721272void PSOutputDev::writeDocSetup(Catalog *catalog,
    1273                 int firstPage, int lastPage,
     1273                                int firstPage, int lastPage,
    12741274                                GBool duplexA) {
    12751275  Page *page;
     
    12941294    for (i = 0; i < annots->getNumAnnots(); ++i) {
    12951295      if (annots->getAnnot(i)->getAppearance(&obj1)->isStream()) {
    1296     obj1.streamGetDict()->lookup("Resources", &obj2);
    1297     if (obj2.isDict()) {
    1298       setupResources(obj2.getDict());
    1299     }
    1300     obj2.free();
     1296        obj1.streamGetDict()->lookup("Resources", &obj2);
     1297        if (obj2.isDict()) {
     1298          setupResources(obj2.getDict());
     1299        }
     1300        obj2.free();
    13011301      }
    13021302      obj1.free();
     
    13071307    if (mode != psModeEPS && !manualCtrl) {
    13081308      writePSFmt("%d %d %s pdfSetup\n",
    1309         paperWidth, paperHeight, duplexA ? "true" : "false");
     1309                paperWidth, paperHeight, duplexA ? "true" : "false");
    13101310    }
    13111311#if OPI_SUPPORT
     
    13331333    writePS(embFontList->getCString());
    13341334    if (level == psLevel1Sep || level == psLevel2Sep ||
    1335     level == psLevel3Sep) {
     1335        level == psLevel3Sep) {
    13361336      writePS("%%DocumentProcessColors:");
    13371337      if (processColors & psProcessCyan) {
    1338     writePS(" Cyan");
    1339     }
     1338        writePS(" Cyan");
     1339        }
    13401340      if (processColors & psProcessMagenta) {
    1341     writePS(" Magenta");
     1341        writePS(" Magenta");
    13421342      }
    13431343      if (processColors & psProcessYellow) {
    1344     writePS(" Yellow");
     1344        writePS(" Yellow");
    13451345      }
    13461346      if (processColors & psProcessBlack) {
    1347     writePS(" Black");
     1347        writePS(" Black");
    13481348      }
    13491349      writePS("\n");
    13501350      writePS("%%DocumentCustomColors:");
    13511351      for (cc = customColors; cc; cc = cc->next) {
    1352     writePSFmt(" (%s)", cc->name->getCString());
     1352        writePSFmt(" (%s)", cc->name->getCString());
    13531353      }
    13541354      writePS("\n");
    13551355      writePS("%%CMYKCustomColor:\n");
    13561356      for (cc = customColors; cc; cc = cc->next) {
    1357     writePSFmt("%%%%+ %g %g %g %g (%s)\n",
    1358            cc->c, cc->m, cc->y, cc->k, cc->name->getCString());
     1357        writePSFmt("%%%%+ %g %g %g %g (%s)\n",
     1358                   cc->c, cc->m, cc->y, cc->k, cc->name->getCString());
    13591359      }
    13601360    }
     
    13791379      skip = gFalse;
    13801380      if ((xObjDict.dictGetValNF(i, &xObjRef)->isRef())) {
    1381     ref0 = xObjRef.getRef();
    1382     for (j = 0; j < xobjStack->getLength(); ++j) {
    1383       ref1 = *(Ref *)xobjStack->get(j);
    1384       if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
    1385         skip = gTrue;
    1386         break;
    1387       }
    1388     }
    1389     if (!skip) {
    1390       xobjStack->append(&ref0);
    1391     }
     1381        ref0 = xObjRef.getRef();
     1382        for (j = 0; j < xobjStack->getLength(); ++j) {
     1383          ref1 = *(Ref *)xobjStack->get(j);
     1384          if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
     1385            skip = gTrue;
     1386            break;
     1387          }
     1388        }
     1389        if (!skip) {
     1390          xobjStack->append(&ref0);
     1391        }
    13921392      }
    13931393      if (!skip) {
    13941394
    1395     // process the XObject's resource dictionary
    1396     xObjDict.dictGetVal(i, &xObj);
    1397     if (xObj.isStream()) {
    1398       xObj.streamGetDict()->lookup("Resources", &resObj);
    1399       if (resObj.isDict()) {
    1400         setupResources(resObj.getDict());
    1401       }
    1402       resObj.free();
    1403     }
    1404     xObj.free();
     1395        // process the XObject's resource dictionary
     1396        xObjDict.dictGetVal(i, &xObj);
     1397        if (xObj.isStream()) {
     1398          xObj.streamGetDict()->lookup("Resources", &resObj);
     1399          if (resObj.isDict()) {
     1400            setupResources(resObj.getDict());
     1401          }
     1402          resObj.free();
     1403        }
     1404        xObj.free();
    14051405      }
    14061406
    14071407      if (xObjRef.isRef() && !skip) {
    1408     xobjStack->del(xobjStack->getLength() - 1);
     1408        xobjStack->del(xobjStack->getLength() - 1);
    14091409      }
    14101410      xObjRef.free();
     
    14221422      skip = gFalse;
    14231423      if ((patDict.dictGetValNF(i, &patRef)->isRef())) {
    1424     ref0 = patRef.getRef();
    1425     for (j = 0; j < xobjStack->getLength(); ++j) {
    1426       ref1 = *(Ref *)xobjStack->get(j);
    1427       if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
    1428         skip = gTrue;
    1429         break;
    1430       }
    1431     }
    1432     if (!skip) {
    1433       xobjStack->append(&ref0);
    1434     }
     1424        ref0 = patRef.getRef();
     1425        for (j = 0; j < xobjStack->getLength(); ++j) {
     1426          ref1 = *(Ref *)xobjStack->get(j);
     1427          if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
     1428            skip = gTrue;
     1429            break;
     1430          }
     1431        }
     1432        if (!skip) {
     1433          xobjStack->append(&ref0);
     1434        }
    14351435      }
    14361436      if (!skip) {
    14371437
    1438     // process the Pattern's resource dictionary
    1439     patDict.dictGetVal(i, &pat);
    1440     if (pat.isStream()) {
    1441       pat.streamGetDict()->lookup("Resources", &resObj);
    1442       if (resObj.isDict()) {
    1443         setupResources(resObj.getDict());
    1444       }
    1445       resObj.free();
    1446     }
    1447     pat.free();
     1438        // process the Pattern's resource dictionary
     1439        patDict.dictGetVal(i, &pat);
     1440        if (pat.isStream()) {
     1441          pat.streamGetDict()->lookup("Resources", &resObj);
     1442          if (resObj.isDict()) {
     1443            setupResources(resObj.getDict());
     1444          }
     1445          resObj.free();
     1446        }
     1447        pat.free();
    14481448      }
    14491449
    14501450      if (patRef.isRef() && !skip) {
    1451     xobjStack->del(xobjStack->getLength() - 1);
     1451        xobjStack->del(xobjStack->getLength() - 1);
    14521452      }
    14531453      patRef.free();
     
    14801480    for (i = 0; i < gfxFontDict->getNumFonts(); ++i) {
    14811481      if ((font = gfxFontDict->getFont(i))) {
    1482     setupFont(font, resDict);
     1482        setupFont(font, resDict);
    14831483      }
    14841484    }
     
    15071507  for (i = 0; i < fontIDLen; ++i) {
    15081508    if (fontIDs[i].num == font->getID()->num &&
    1509     fontIDs[i].gen == font->getID()->gen) {
     1509        fontIDs[i].gen == font->getID()->gen) {
    15101510      return;
    15111511    }
     
    15291529  // check for embedded Type 1 font
    15301530  } else if (globalParams->getPSEmbedType1() &&
    1531          font->getType() == fontType1 &&
    1532          font->getEmbeddedFontID(&fontFileID)) {
     1531             font->getType() == fontType1 &&
     1532             font->getEmbeddedFontID(&fontFileID)) {
    15331533    psName = filterPSName(font->getEmbeddedFontName());
    15341534    setupEmbeddedType1Font(&fontFileID, psName);
     
    15361536  // check for embedded Type 1C font
    15371537  } else if (globalParams->getPSEmbedType1() &&
    1538          font->getType() == fontType1C &&
    1539          font->getEmbeddedFontID(&fontFileID)) {
     1538             font->getType() == fontType1C &&
     1539             font->getEmbeddedFontID(&fontFileID)) {
    15401540    psName = filterPSName(font->getEmbeddedFontName());
    15411541    setupEmbeddedType1CFont(font, &fontFileID, psName);
     
    15431543  // check for external Type 1 font file
    15441544  } else if (globalParams->getPSEmbedType1() &&
    1545          font->getType() == fontType1 &&
    1546          font->getExtFontFile()) {
     1545             font->getType() == fontType1 &&
     1546             font->getExtFontFile()) {
    15471547    // this assumes that the PS font name matches the PDF font name
    15481548    psName = font->getName()->copy();
     
    15511551  // check for embedded TrueType font
    15521552  } else if (globalParams->getPSEmbedTrueType() &&
    1553          font->getType() == fontTrueType &&
    1554          font->getEmbeddedFontID(&fontFileID)) {
     1553             font->getType() == fontTrueType &&
     1554             font->getEmbeddedFontID(&fontFileID)) {
    15551555    psName = filterPSName(font->getEmbeddedFontName());
    15561556    setupEmbeddedTrueTypeFont(font, &fontFileID, psName);
     
    15581558  // check for external TrueType font file
    15591559  } else if (globalParams->getPSEmbedTrueType() &&
    1560          font->getType() == fontTrueType &&
    1561          font->getExtFontFile()) {
     1560             font->getType() == fontTrueType &&
     1561             font->getExtFontFile()) {
    15621562    psName = setupExternalTrueTypeFont(font);
    15631563
    15641564  // check for embedded CID PostScript font
    15651565  } else if (globalParams->getPSEmbedCIDPostScript() &&
    1566          font->getType() == fontCIDType0C &&
    1567          font->getEmbeddedFontID(&fontFileID)) {
     1566             font->getType() == fontCIDType0C &&
     1567             font->getEmbeddedFontID(&fontFileID)) {
    15681568    psName = filterPSName(font->getEmbeddedFontName());
    15691569    setupEmbeddedCIDType0Font(font, &fontFileID, psName);
     
    15711571  // check for embedded CID TrueType font
    15721572  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1573          font->getType() == fontCIDType2 &&
    1574          font->getEmbeddedFontID(&fontFileID)) {
     1573             font->getType() == fontCIDType2 &&
     1574             font->getEmbeddedFontID(&fontFileID)) {
    15751575    psName = filterPSName(font->getEmbeddedFontName());
    15761576    setupEmbeddedCIDTrueTypeFont(font, &fontFileID, psName, gTrue);
     
    15781578  } else if (font->getType() == fontType3) {
    15791579    sprintf(type3Name, "T3_%d_%d",
    1580         font->getID()->num, font->getID()->gen);
     1580            font->getID()->num, font->getID()->gen);
    15811581    psName = new GooString(type3Name);
    15821582    setupType3Font(font, psName, parentResDict);
     
    15841584  // check for external CID TrueType font file
    15851585  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1586          font->getType() == fontCIDType2 &&
    1587          font->getExtFontFile()) {
     1586             font->getType() == fontCIDType2 &&
     1587             font->getExtFontFile()) {
    15881588    psName = setupExternalCIDTrueTypeFont(font, font->getExtFontFile());
    15891589
     
    15951595    if (name) {
    15961596      for (i = 0; psFonts[i]; ++i) {
    1597     if (name->cmp(psFonts[i]) == 0) {
    1598       psName = new GooString(psFonts[i]);
    1599       break;
    1600     }
     1597        if (name->cmp(psFonts[i]) == 0) {
     1598          psName = new GooString(psFonts[i]);
     1599          break;
     1600        }
    16011601      }
    16021602    }
    16031603    if (!psName) {
    16041604      if (font->isFixedWidth()) {
    1605     i = 8;
     1605        i = 8;
    16061606      } else if (font->isSerif()) {
    1607     i = 4;
     1607        i = 4;
    16081608      } else {
    1609     i = 0;
     1609        i = 0;
    16101610      }
    16111611      if (font->isBold()) {
    1612     i += 2;
     1612        i += 2;
    16131613      }
    16141614      if (font->isItalic()) {
    1615     i += 1;
     1615        i += 1;
    16161616      }
    16171617      psName = new GooString(psSubstFonts[i].psName);
    16181618      for (code = 0; code < 256; ++code) {
    1619     if ((charName = ((Gfx8BitFont *)font)->getCharName(code)) &&
    1620         charName[0] == 'm' && charName[1] == '\0') {
    1621       break;
    1622     }
     1619        if ((charName = ((Gfx8BitFont *)font)->getCharName(code)) &&
     1620            charName[0] == 'm' && charName[1] == '\0') {
     1621          break;
     1622        }
    16231623      }
    16241624      if (code < 256) {
    1625     w1 = ((Gfx8BitFont *)font)->getWidth(code);
     1625        w1 = ((Gfx8BitFont *)font)->getWidth(code);
    16261626      } else {
    1627     w1 = 0;
     1627        w1 = 0;
    16281628      }
    16291629      w2 = psSubstFonts[i].mWidth;
    16301630      xs = w1 / w2;
    16311631      if (xs < 0.1) {
    1632     xs = 1;
     1632        xs = 1;
    16331633      }
    16341634      if (font->getType() == fontType3) {
    1635     // This is a hack which makes it possible to substitute for some
    1636     // Type 3 fonts.  The problem is that it's impossible to know what
    1637     // the base coordinate system used in the font is without actually
    1638     // rendering the font.
    1639     ys = xs;
    1640     fm = font->getFontMatrix();
    1641     if (fm[0] != 0) {
    1642       ys *= fm[3] / fm[0];
    1643     }
     1635        // This is a hack which makes it possible to substitute for some
     1636        // Type 3 fonts.  The problem is that it's impossible to know what
     1637        // the base coordinate system used in the font is without actually
     1638        // rendering the font.
     1639        ys = xs;
     1640        fm = font->getFontMatrix();
     1641        if (fm[0] != 0) {
     1642          ys *= fm[3] / fm[0];
     1643        }
    16441644      } else {
    1645     ys = 1;
     1645        ys = 1;
    16461646      }
    16471647    }
     
    16491649  // do 16-bit font substitution
    16501650  } else if ((fontParam = globalParams->
    1651             getPSFont16(font->getName(),
    1652                 ((GfxCIDFont *)font)->getCollection(),
    1653                 font->getWMode()))) {
     1651                getPSFont16(font->getName(),
     1652                            ((GfxCIDFont *)font)->getCollection(),
     1653                            font->getWMode()))) {
    16541654    subst = gTrue;
    16551655    psName = fontParam->psFontName->copy();
     
    16571657      font16EncSize += 16;
    16581658      font16Enc = (PSFont16Enc *)greallocn(font16Enc,
    1659                        font16EncSize, sizeof(PSFont16Enc));
     1659                                           font16EncSize, sizeof(PSFont16Enc));
    16601660    }
    16611661    font16Enc[font16EncLen].fontID = *font->getID();
     
    16661666    } else {
    16671667      error(-1, "Couldn't find Unicode map for 16-bit font encoding '%s'",
    1668         font16Enc[font16EncLen].enc->getCString());
     1668            font16Enc[font16EncLen].enc->getCString());
    16691669    }
    16701670
    16711671  // try the display font for embedding
    16721672  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1673          ((GfxCIDFont *)font)->getCollection() &&
    1674          (dfp = globalParams->
    1675           getDisplayFont(font)) &&
    1676          dfp->kind == displayFontTT) {
     1673             ((GfxCIDFont *)font)->getCollection() &&
     1674             (dfp = globalParams->
     1675              getDisplayFont(font)) &&
     1676             dfp->kind == displayFontTT) {
    16771677    psName = setupExternalCIDTrueTypeFont(font, dfp->tt.fileName, dfp->tt.faceIndex);
    16781678
     
    16801680  } else {
    16811681    error(-1, "Couldn't find a font to substitute for '%s' ('%s' character collection)",
    1682       font->getName() ? font->getName()->getCString() : "(unnamed)",
    1683       ((GfxCIDFont *)font)->getCollection()
    1684         ? ((GfxCIDFont *)font)->getCollection()->getCString()
    1685         : "(unknown)");
     1682          font->getName() ? font->getName()->getCString() : "(unnamed)",
     1683          ((GfxCIDFont *)font)->getCollection()
     1684            ? ((GfxCIDFont *)font)->getCollection()->getCString()
     1685            : "(unknown)");
    16861686    return;
    16871687  }
     
    16911691    if (level == psLevel3 || level == psLevel3Sep) {
    16921692      writePSFmt("/F%d_%d /%s %d pdfMakeFont16L3\n",
    1693         font->getID()->num, font->getID()->gen, psName->getCString(),
    1694         font->getWMode());
     1693                font->getID()->num, font->getID()->gen, psName->getCString(),
     1694                font->getWMode());
    16951695    } else {
    16961696      writePSFmt("/F%d_%d /%s %d pdfMakeFont16\n",
    1697         font->getID()->num, font->getID()->gen, psName->getCString(),
    1698         font->getWMode());
     1697                font->getID()->num, font->getID()->gen, psName->getCString(),
     1698                font->getWMode());
    16991699    }
    17001700  } else {
    17011701    writePSFmt("/F%d_%d /%s %g %g\n",
    1702            font->getID()->num, font->getID()->gen, psName->getCString(),
    1703            xs, ys);
     1702               font->getID()->num, font->getID()->gen, psName->getCString(),
     1703               xs, ys);
    17041704    for (i = 0; i < 256; i += 8) {
    17051705      writePSFmt((i == 0) ? "[ " : "  ");
    17061706      for (j = 0; j < 8; ++j) {
    1707     if (font->getType() == fontTrueType &&
    1708         !subst &&
    1709         !((Gfx8BitFont *)font)->getHasEncoding()) {
    1710       sprintf(buf, "c%02x", i+j);
    1711       charName = buf;
    1712     } else {
    1713       charName = ((Gfx8BitFont *)font)->getCharName(i+j);
    1714       // this is a kludge for broken PDF files that encode char 32
    1715       // as .notdef
    1716       if (i+j == 32 && charName && !strcmp(charName, ".notdef")) {
    1717         charName = "space";
    1718       }
    1719     }
    1720     writePS("/");
    1721     writePSName(charName ? charName : (char *)".notdef");
    1722     // the empty name is legal in PDF and PostScript, but PostScript
    1723     // uses a double-slash (//...) for "immediately evaluated names",
    1724     // so we need to add a space character here
    1725     if (charName && !charName[0]) {
    1726       writePS(" ");
    1727     }
     1707        if (font->getType() == fontTrueType &&
     1708            !subst &&
     1709            !((Gfx8BitFont *)font)->getHasEncoding()) {
     1710          sprintf(buf, "c%02x", i+j);
     1711          charName = buf;
     1712        } else {
     1713          charName = ((Gfx8BitFont *)font)->getCharName(i+j);
     1714          // this is a kludge for broken PDF files that encode char 32
     1715          // as .notdef
     1716          if (i+j == 32 && charName && !strcmp(charName, ".notdef")) {
     1717            charName = "space";
     1718          }
     1719        }
     1720        writePS("/");
     1721        writePSName(charName ? charName : (char *)".notdef");
     1722        // the empty name is legal in PDF and PostScript, but PostScript
     1723        // uses a double-slash (//...) for "immediately evaluated names",
     1724        // so we need to add a space character here
     1725        if (charName && !charName[0]) {
     1726          writePS(" ");
     1727        }
    17281728      }
    17291729      writePS((i == 256-8) ? (char *)"]\n" : (char *)"\n");
     
    17481748  for (i = 0; i < fontFileIDLen; ++i) {
    17491749    if (fontFileIDs[i].num == id->num &&
    1750     fontFileIDs[i].gen == id->gen)
     1750        fontFileIDs[i].gen == id->gen)
    17511751      return;
    17521752  }
     
    18091809    }
    18101810    if (!((start[i] >= '0' && start[i] <= '9') ||
    1811       (start[i] >= 'A' && start[i] <= 'F') ||
    1812       (start[i] >= 'a' && start[i] <= 'f')))
     1811          (start[i] >= 'A' && start[i] <= 'F') ||
     1812          (start[i] >= 'a' && start[i] <= 'f')))
    18131813      binMode = gTrue;
    18141814  }
     
    18271827    while (i < length2) {
    18281828      if ((c = strObj.streamGetChar()) == EOF) {
    1829     break;
     1829        break;
    18301830      }
    18311831      writePSChar(hexChar[(c >> 4) & 0x0f]);
    18321832      writePSChar(hexChar[c & 0x0f]);
    18331833      if (++i % 32 == 0) {
    1834     writePSChar('\n');
     1834        writePSChar('\n');
    18351835      }
    18361836    }
     
    18461846    for (i = 4; i < length2; ++i) {
    18471847      if ((c = strObj.streamGetChar()) == EOF) {
    1848     break;
     1848        break;
    18491849      }
    18501850      writePSChar(c);
     
    18551855  for (i = 0; i < 8; ++i) {
    18561856    writePS("00000000000000000000000000000000"
    1857         "00000000000000000000000000000000\n");
     1857            "00000000000000000000000000000000\n");
    18581858  }
    18591859  writePS("cleartomark\n");
     
    18851885    fontFileNameSize += 64;
    18861886    fontFileNames = (GooString **)greallocn(fontFileNames,
    1887                       fontFileNameSize, sizeof(GooString *));
     1887                                          fontFileNameSize, sizeof(GooString *));
    18881888    psFileNames = (GooString **)greallocn(psFileNames,
    1889                        fontFileNameSize, sizeof(GooString *));
     1889                                       fontFileNameSize, sizeof(GooString *));
    18901890  }
    18911891  fontFileNames[fontFileNameLen] = fileName->copy();
     
    19141914
    19151915void PSOutputDev::setupEmbeddedType1CFont(GfxFont *font, Ref *id,
    1916                       GooString *psName) {
     1916                                          GooString *psName) {
    19171917  char *fontBuf;
    19181918  int fontLen;
     
    19231923  for (i = 0; i < fontFileIDLen; ++i) {
    19241924    if (fontFileIDs[i].num == id->num &&
    1925     fontFileIDs[i].gen == id->gen)
     1925        fontFileIDs[i].gen == id->gen)
    19261926      return;
    19271927  }
     
    19531953
    19541954void PSOutputDev::setupEmbeddedTrueTypeFont(GfxFont *font, Ref *id,
    1955                         GooString *psName) {
     1955                                            GooString *psName) {
    19561956  char unique[32];
    19571957  char *fontBuf;
     
    19641964  for (i = 0; i < fontFileIDLen; ++i) {
    19651965    if (fontFileIDs[i].num == id->num &&
    1966     fontFileIDs[i].gen == id->gen) {
     1966        fontFileIDs[i].gen == id->gen) {
    19671967      sprintf(unique, "_%d", nextTrueTypeNum++);
    19681968      psName->append(unique);
     
    19911991    codeToGID = ((Gfx8BitFont *)font)->getCodeToGIDMap(ffTT);
    19921992    ffTT->convertToType42(psName->getCString(),
    1993               ((Gfx8BitFont *)font)->getHasEncoding()
    1994                 ? ((Gfx8BitFont *)font)->getEncoding()
    1995                 : (char **)NULL,
    1996               codeToGID, outputFunc, outputStream);
     1993                          ((Gfx8BitFont *)font)->getHasEncoding()
     1994                            ? ((Gfx8BitFont *)font)->getEncoding()
     1995                            : (char **)NULL,
     1996                          codeToGID, outputFunc, outputStream);
    19971997    gfree(codeToGID);
    19981998    delete ffTT;
     
    20272027      fontFileNameSize += 64;
    20282028      fontFileNames =
    2029     (GooString **)greallocn(fontFileNames,
    2030                   fontFileNameSize, sizeof(GooString *));
     2029        (GooString **)greallocn(fontFileNames,
     2030                              fontFileNameSize, sizeof(GooString *));
    20312031      psFileNames =
    2032     (GooString **)greallocn(psFileNames,
    2033                  fontFileNameSize, sizeof(GooString *));
     2032        (GooString **)greallocn(psFileNames,
     2033                             fontFileNameSize, sizeof(GooString *));
    20342034    }
    20352035  }
     
    20492049    codeToGID = ((Gfx8BitFont *)font)->getCodeToGIDMap(ffTT);
    20502050    ffTT->convertToType42(psName->getCString(),
    2051               ((Gfx8BitFont *)font)->getHasEncoding()
    2052                 ? ((Gfx8BitFont *)font)->getEncoding()
    2053                 : (char **)NULL,
    2054               codeToGID, outputFunc, outputStream);
     2051                          ((Gfx8BitFont *)font)->getHasEncoding()
     2052                            ? ((Gfx8BitFont *)font)->getEncoding()
     2053                            : (char **)NULL,
     2054                          codeToGID, outputFunc, outputStream);
    20552055    delete ffTT;
    20562056  }
     
    20912091      fontFileNameSize += 64;
    20922092      fontFileNames =
    2093     (GooString **)grealloc(fontFileNames,
    2094                  fontFileNameSize * sizeof(GooString *));
     2093        (GooString **)grealloc(fontFileNames,
     2094                             fontFileNameSize * sizeof(GooString *));
    20952095      psFileNames =
    2096     (GooString **)grealloc(psFileNames,
    2097                  fontFileNameSize * sizeof(GooString *));
     2096        (GooString **)grealloc(psFileNames,
     2097                             fontFileNameSize * sizeof(GooString *));
    20982098    }
    20992099  }
     
    21122112      int n = ((GfxCIDFont *)font)->getCIDToGIDLen();
    21132113      if (n) {
    2114     codeToGID = (Gushort *)gmalloc(n * sizeof(Gushort));
    2115     memcpy(codeToGID, ((GfxCIDFont *)font)->getCIDToGID(), n * sizeof(Gushort));
     2114        codeToGID = (Gushort *)gmalloc(n * sizeof(Gushort));
     2115        memcpy(codeToGID, ((GfxCIDFont *)font)->getCIDToGID(), n * sizeof(Gushort));
    21162116      } else {
    2117     codeToGID = ((GfxCIDFont *)font)->getCodeToGIDMap(ffTT, &n);
     2117        codeToGID = ((GfxCIDFont *)font)->getCodeToGIDMap(ffTT, &n);
    21182118      }
    21192119      if (globalParams->getPSLevel() >= psLevel3) {
    2120     // Level 3: use a CID font
    2121     ffTT->convertToCIDType2(psName->getCString(),
    2122                 codeToGID, n, gTrue,
    2123                 outputFunc, outputStream);
     2120        // Level 3: use a CID font
     2121        ffTT->convertToCIDType2(psName->getCString(),
     2122                                codeToGID, n, gTrue,
     2123                                outputFunc, outputStream);
    21242124      } else {
    2125     // otherwise: use a non-CID composite font
    2126     ffTT->convertToType0(psName->getCString(),
    2127                  codeToGID, n, gTrue,
    2128                  outputFunc, outputStream);
     2125        // otherwise: use a non-CID composite font
     2126        ffTT->convertToType0(psName->getCString(),
     2127                             codeToGID, n, gTrue,
     2128                             outputFunc, outputStream);
    21292129      }
    21302130      gfree(codeToGID);
     
    21382138
    21392139void PSOutputDev::setupEmbeddedCIDType0Font(GfxFont *font, Ref *id,
    2140                         GooString *psName) {
     2140                                            GooString *psName) {
    21412141  char *fontBuf;
    21422142  int fontLen;
     
    21472147  for (i = 0; i < fontFileIDLen; ++i) {
    21482148    if (fontFileIDs[i].num == id->num &&
    2149     fontFileIDs[i].gen == id->gen)
     2149        fontFileIDs[i].gen == id->gen)
    21502150      return;
    21512151  }
     
    21832183
    21842184void PSOutputDev::setupEmbeddedCIDTrueTypeFont(GfxFont *font, Ref *id,
    2185                            GooString *psName,
    2186                            GBool needVerticalMetrics) {
     2185                                               GooString *psName,
     2186                                               GBool needVerticalMetrics) {
    21872187  char unique[32];
    21882188  char *fontBuf;
     
    21942194  for (i = 0; i < fontFileIDLen; ++i) {
    21952195    if (fontFileIDs[i].num == id->num &&
    2196     fontFileIDs[i].gen == id->gen) {
     2196        fontFileIDs[i].gen == id->gen) {
    21972197      sprintf(unique, "_%d", nextTrueTypeNum++);
    21982198      psName->append(unique);
     
    22202220      // Level 3: use a CID font
    22212221      ffTT->convertToCIDType2(psName->getCString(),
    2222                   ((GfxCIDFont *)font)->getCIDToGID(),
    2223                   ((GfxCIDFont *)font)->getCIDToGIDLen(),
    2224                   needVerticalMetrics,
    2225                   outputFunc, outputStream);
     2222                              ((GfxCIDFont *)font)->getCIDToGID(),
     2223                              ((GfxCIDFont *)font)->getCIDToGIDLen(),
     2224                              needVerticalMetrics,
     2225                              outputFunc, outputStream);
    22262226    } else {
    22272227      // otherwise: use a non-CID composite font
    22282228      ffTT->convertToType0(psName->getCString(),
    2229                ((GfxCIDFont *)font)->getCIDToGID(),
    2230                ((GfxCIDFont *)font)->getCIDToGIDLen(),
    2231                needVerticalMetrics,
    2232                outputFunc, outputStream);
     2229                           ((GfxCIDFont *)font)->getCIDToGID(),
     2230                           ((GfxCIDFont *)font)->getCIDToGIDLen(),
     2231                           needVerticalMetrics,
     2232                           outputFunc, outputStream);
    22332233    }
    22342234    delete ffTT;
     
    22412241
    22422242void PSOutputDev::setupType3Font(GfxFont *font, GooString *psName,
    2243                 Dict *parentResDict) {
     2243                                Dict *parentResDict) {
    22442244  Dict *resDict;
    22452245  Dict *charProcs;
     
    22712271  m = font->getFontMatrix();
    22722272  writePSFmt("/FontMatrix [%g %g %g %g %g %g] def\n",
    2273          m[0], m[1], m[2], m[3], m[4], m[5]);
     2273             m[0], m[1], m[2], m[3], m[4], m[5]);
    22742274  m = font->getFontBBox();
    22752275  writePSFmt("/FontBBox [%g %g %g %g] def\n",
    2276          m[0], m[1], m[2], m[3]);
     2276             m[0], m[1], m[2], m[3]);
    22772277  writePS("/Encoding 256 array def\n");
    22782278  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
     
    23052305      charProc.free();
    23062306      if (t3String) {
    2307     if (t3Cacheable) {
    2308       sprintf(buf, "%g %g %g %g %g %g setcachedevice\n",
    2309           t3WX, t3WY, t3LLX, t3LLY, t3URX, t3URY);
    2310     } else {
    2311       sprintf(buf, "%g %g setcharwidth\n", t3WX, t3WY);
    2312     }
    2313     (*outputFunc)(outputStream, buf, strlen(buf));
    2314     (*outputFunc)(outputStream, t3String->getCString(),
    2315               t3String->getLength());
    2316     delete t3String;
    2317     t3String = NULL;
     2307        if (t3Cacheable) {
     2308          sprintf(buf, "%g %g %g %g %g %g setcachedevice\n",
     2309                  t3WX, t3WY, t3LLX, t3LLY, t3URX, t3URY);
     2310        } else {
     2311          sprintf(buf, "%g %g setcharwidth\n", t3WX, t3WY);
     2312        }
     2313        (*outputFunc)(outputStream, buf, strlen(buf));
     2314        (*outputFunc)(outputStream, t3String->getCString(),
     2315                      t3String->getLength());
     2316        delete t3String;
     2317        t3String = NULL;
    23182318      }
    23192319      (*outputFunc)(outputStream, "Q\n", 2);
     
    23462346      xObjDict.dictGetVal(i, &xObj);
    23472347      if (xObj.isStream()) {
    2348     xObj.streamGetDict()->lookup("Subtype", &subtypeObj);
    2349     if (subtypeObj.isName("Image")) {
    2350       if (xObjRef.isRef()) {
    2351         setupImage(xObjRef.getRef(), xObj.getStream());
    2352       } else {
    2353         error(-1, "Image in resource dict is not an indirect reference");
    2354       }
    2355     }
    2356     subtypeObj.free();
     2348        xObj.streamGetDict()->lookup("Subtype", &subtypeObj);
     2349        if (subtypeObj.isName("Image")) {
     2350          if (xObjRef.isRef()) {
     2351            setupImage(xObjRef.getRef(), xObj.getStream());
     2352          } else {
     2353            error(-1, "Image in resource dict is not an indirect reference");
     2354          }
     2355        }
     2356        subtypeObj.free();
    23572357      }
    23582358      xObj.free();
     
    23922392      ++col;
    23932393      for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    2394     do {
    2395       c = str->getChar();
    2396     } while (c == '\n' || c == '\r');
    2397     if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2398       break;
    2399     }
    2400     ++col;
     2394        do {
     2395          c = str->getChar();
     2396        } while (c == '\n' || c == '\r');
     2397        if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2398          break;
     2399        }
     2400        ++col;
    24012401      }
    24022402    }
     
    24282428      ++col;
    24292429      for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    2430     do {
    2431       c = str->getChar();
    2432     } while (c == '\n' || c == '\r');
    2433     if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2434       break;
    2435     }
    2436     writePSChar(c);
    2437     ++col;
     2430        do {
     2431          c = str->getChar();
     2432        } while (c == '\n' || c == '\r');
     2433        if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2434          break;
     2435        }
     2436        writePSChar(c);
     2437        ++col;
    24382438      }
    24392439    }
     
    24962496      if (rotate == 0 || rotate == 180) {
    24972497    if (width > height && width > imgWidth) {
    2498       rotate += 90;
    2499       landscape = gTrue;
    2500     } else {
    2501       landscape = gFalse;
    2502     }
     2498          rotate += 90;
     2499          landscape = gTrue;
     2500        } else {
     2501          landscape = gFalse;
     2502        }
    25032503      } else { // rotate == 90 || rotate == 270
    2504     if (height > width && height > imgWidth) {
    2505       rotate = 270 - rotate;
    2506       landscape = gTrue;
    2507     } else {
    2508       landscape = gFalse;
    2509     }
     2504        if (height > width && height > imgWidth) {
     2505          rotate = 270 - rotate;
     2506          landscape = gTrue;
     2507        } else {
     2508          landscape = gFalse;
     2509        }
    25102510      }
    25112511    }
    25122512      writePSFmt("%%%%PageOrientation: %s\n",
    2513            landscape ? "Landscape" : "Portrait");
     2513               landscape ? "Landscape" : "Portrait");
    25142514      writePS("pdfStartPage\n");
    25152515    if (rotate == 0) {
     
    25382538      yScale = yScale0;
    25392539    } else if ((globalParams->getPSShrinkLarger() &&
    2540     (width > imgWidth2 || height > imgHeight2)) ||
    2541     (globalParams->getPSExpandSmaller() &&
    2542     (width < imgWidth2 && height < imgHeight2))) {
     2540        (width > imgWidth2 || height > imgHeight2)) ||
     2541        (globalParams->getPSExpandSmaller() &&
     2542        (width < imgWidth2 && height < imgHeight2))) {
    25432543      xScale = (double)imgWidth2 / (double)width;
    25442544      yScale = (double)imgHeight2 / (double)height;
    25452545      if (yScale < xScale) {
    2546     xScale = yScale;
     2546        xScale = yScale;
    25472547      } else {
    2548     yScale = xScale;
     2548        yScale = xScale;
    25492549      }
    25502550    } else {
     
    25622562    if (globalParams->getPSCenter()) {
    25632563      if (clipLLX0 < clipURX0 && clipLLY0 < clipURY0) {
    2564     tx += (imgWidth2 - xScale * (clipURX0 - clipLLX0)) / 2;
    2565     ty += (imgHeight2 - yScale * (clipURY0 - clipLLY0)) / 2;
     2564        tx += (imgWidth2 - xScale * (clipURX0 - clipLLX0)) / 2;
     2565        ty += (imgHeight2 - yScale * (clipURY0 - clipLLY0)) / 2;
    25662566      } else {
    25672567      tx += (imgWidth2 - xScale * width) / 2;
     
    25792579    if (clipLLX0 < clipURX0 && clipLLY0 < clipURY0) {
    25802580      writePSFmt("%g %g %g %g re W\n",
    2581         clipLLX0, clipLLY0, clipURX0 - clipLLX0, clipURY0 - clipLLY0);
     2581                clipLLX0, clipLLY0, clipURX0 - clipLLX0, clipURY0 - clipLLY0);
    25822582    } else {
    25832583      writePSFmt("%d %d %d %d re W\n", x1, y1, x2 - x1, y2 - y1);
     
    26552655
    26562656void PSOutputDev::updateCTM(GfxState *state, double m11, double m12,
    2657                 double m21, double m22, double m31, double m32) {
     2657                            double m21, double m22, double m31, double m32) {
    26582658  writePSFmt("[%g %g %g %g %g %g] cm\n", m11, m12, m21, m22, m31, m32);
    26592659}
     
    26682668  for (i = 0; i < length; ++i) {
    26692669    writePSFmt("%g%s",
    2670            dash[i] == 0 ? 1 : dash[i],
    2671            (i == length-1) ? "" : " ");
     2670               dash[i] == 0 ? 1 : dash[i],
     2671               (i == length-1) ? "" : " ");
    26722672  }
    26732673  writePSFmt("] %g d\n", start);
     
    27592759      writePS("[");
    27602760      for (i = 0; i < state->getFillColorSpace()->getNComps(); ++i) {
    2761     if (i > 0) {
    2762       writePS(" ");
    2763       }
    2764     writePSFmt("%g", colToDbl(colorPtr->c[i]));
     2761        if (i > 0) {
     2762          writePS(" ");
     2763      }
     2764        writePSFmt("%g", colToDbl(colorPtr->c[i]));
    27652765      }
    27662766      writePS("] sc\n");
     
    27742774      sepCS->getCMYK(&color, &cmyk);
    27752775      writePSFmt("%g %g %g %g %g (%s) ck\n",
    2776         colToDbl(state->getFillColor()->c[0]),
    2777         colToDbl(cmyk.c), colToDbl(cmyk.m),
    2778         colToDbl(cmyk.y), colToDbl(cmyk.k),
    2779         sepCS->getName()->getCString());
     2776                colToDbl(state->getFillColor()->c[0]),
     2777                colToDbl(cmyk.c), colToDbl(cmyk.m),
     2778                colToDbl(cmyk.y), colToDbl(cmyk.k),
     2779                sepCS->getName()->getCString());
    27802780      addCustomColor(sepCS);
    27812781    } else {
     
    28222822      writePS("[");
    28232823      for (i = 0; i < state->getStrokeColorSpace()->getNComps(); ++i) {
    2824     if (i > 0) {
    2825       writePS(" ");
    2826       }
    2827     writePSFmt("%g", colToDbl(colorPtr->c[i]));
     2824        if (i > 0) {
     2825          writePS(" ");
     2826      }
     2827        writePSFmt("%g", colToDbl(colorPtr->c[i]));
    28282828      }
    28292829      writePS("] SC\n");
     
    28372837      sepCS->getCMYK(&color, &cmyk);
    28382838      writePSFmt("%g %g %g %g %g (%s) CK\n",
    2839         colToDbl(state->getStrokeColor()->c[0]),
    2840         colToDbl(cmyk.c), colToDbl(cmyk.m),
    2841         colToDbl(cmyk.y), colToDbl(cmyk.k),
    2842         sepCS->getName()->getCString());
     2839                colToDbl(state->getStrokeColor()->c[0]),
     2840                colToDbl(cmyk.c), colToDbl(cmyk.m),
     2841                colToDbl(cmyk.y), colToDbl(cmyk.k),
     2842                sepCS->getName()->getCString());
    28432843      addCustomColor(sepCS);
    28442844    } else {
     
    28842884  sepCS->getCMYK(&color, &cmyk);
    28852885  cc = new PSOutCustomColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    2886                 colToDbl(cmyk.y), colToDbl(cmyk.k),
    2887                 sepCS->getName()->copy());
     2886                            colToDbl(cmyk.y), colToDbl(cmyk.k),
     2887                            sepCS->getName()->copy());
    28882888  cc->next = customColors;
    28892889  customColors = cc;
     
    29052905  if (state->getFont()) {
    29062906    writePSFmt("/F%d_%d %g Tf\n",
    2907            state->getFont()->getID()->num, state->getFont()->getID()->gen,
    2908            fabs(state->getFontSize()) < 0.00001 ? 0.00001
    2909                                                 : state->getFontSize());
     2907               state->getFont()->getID()->num, state->getFont()->getID()->gen,
     2908               fabs(state->getFontSize()) < 0.00001 ? 0.00001
     2909                                                    : state->getFontSize());
    29102910  }
    29112911}
     
    29202920  } else {
    29212921  writePSFmt("[%g %g %g %g %g %g] Tm\n",
    2922          mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     2922             mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    29232923  }
    29242924}
     
    29912991
    29922992void PSOutputDev::tilingPatternFill(GfxState *state, Object *str,
    2993                     int paintType, Dict *resDict,
    2994                     double *mat, double *bbox,
    2995                     int x0, int y0, int x1, int y1,
    2996                     double xStep, double yStep) {
     2993                                    int paintType, Dict *resDict,
     2994                                    double *mat, double *bbox,
     2995                                    int x0, int y0, int x1, int y1,
     2996                                    double xStep, double yStep) {
    29972997  PDFRectangle box;
    29982998  Gfx *gfx;
     
    30033003  writePS("/FontMatrix [1 0 0 1 0 0] def\n");
    30043004  writePSFmt("/FontBBox [%g %g %g %g] def\n",
    3005          bbox[0], bbox[1], bbox[2], bbox[3]);
     3005             bbox[0], bbox[1], bbox[2], bbox[3]);
    30063006  writePS("/Encoding 256 array def\n");
    30073007  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
     
    30263026  if (paintType == 2) {
    30273027    writePSFmt("%g 0 %g %g %g %g setcachedevice\n",
    3028            xStep, bbox[0], bbox[1], bbox[2], bbox[3]);
     3028               xStep, bbox[0], bbox[1], bbox[2], bbox[3]);
    30293029  } else {
    30303030    writePSFmt("%g 0 setcharwidth\n", xStep);
     
    30443044  writePSFmt("/xpdfTile%d findfont setfont\n", numTilingPatterns);
    30453045  writePSFmt("gsave [%g %g %g %g %g %g] concat\n",
    3046          mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     3046             mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    30473047  writePSFmt("%d 1 %d { %g exch %g mul m %d 1 %d { pop (x) show } for } for\n",
    3048          y0, y1 - 1, x0 * xStep, yStep, x0, x1 - 1);
     3048             y0, y1 - 1, x0 * xStep, yStep, x0, x1 - 1);
    30493049  writePS("grestore\n");
    30503050}
    30513051
    30523052void PSOutputDev::functionShadedFill(GfxState *state,
    3053                      GfxFunctionShading *shading) {
     3053                                     GfxFunctionShading *shading) {
    30543054  double x0, y0, x1, y1;
    30553055  double *mat;
     
    30593059  mat = shading->getMatrix();
    30603060  writePSFmt("/mat [%g %g %g %g %g %g] def\n",
    3061          mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     3061             mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    30623062  writePSFmt("/n %d def\n", shading->getColorSpace()->getNComps());
    30633063  if (shading->getNFuncs() == 1) {
     
    30693069    for (i = 0; i < shading->getNFuncs(); ++i) {
    30703070      if (i < shading->getNFuncs() - 1) {
    3071     writePS("2 copy\n");
     3071        writePS("2 copy\n");
    30723072      }
    30733073      cvtFunction(shading->getFunc(i));
    30743074      writePS("exec\n");
    30753075      if (i < shading->getNFuncs() - 1) {
    3076     writePS("3 1 roll\n");
     3076        writePS("3 1 roll\n");
    30773077      }
    30783078    }
     
    31503150    for (i = 0; i < shading->getNFuncs(); ++i) {
    31513151      if (i < shading->getNFuncs() - 1) {
    3152     writePS("dup\n");
     3152        writePS("dup\n");
    31533153      }
    31543154      cvtFunction(shading->getFunc(i));
    31553155      writePS("exec\n");
    31563156      if (i < shading->getNFuncs() - 1) {
    3157     writePS("exch\n");
     3157        writePS("exch\n");
    31583158      }
    31593159    }
     
    31643164
    31653165void PSOutputDev::radialShadedFill(GfxState *state,
    3166                    GfxRadialShading *shading) {
     3166                                   GfxRadialShading *shading) {
    31673167  double x0, y0, r0, x1, y1, r1, t0, t1, sMin, sMax;
    31683168  double xMin, yMin, xMax, yMax;
     
    31933193      sMin = (sqrt(sMin) - r0) / (r1 - r0);
    31943194      if (sMin > 0) {
    3195     sMin = 0;
     3195        sMin = 0;
    31963196      } else if (sMin < -20) {
    3197     // sanity check
    3198     sMin = -20;
     3197        // sanity check
     3198        sMin = -20;
    31993199      }
    32003200    }
     
    32153215      sMax = (sqrt(sMax) - r0) / (r1 - r0);
    32163216      if (sMax < 1) {
    3217     sMax = 1;
     3217        sMax = 1;
    32183218      } else if (sMax > 20) {
    3219     // sanity check
    3220     sMax = 20;
     3219        // sanity check
     3220        sMax = 20;
    32213221      }
    32223222    }
     
    32453245    for (i = 0; i < shading->getNFuncs(); ++i) {
    32463246      if (i < shading->getNFuncs() - 1) {
    3247     writePS("dup\n");
     3247        writePS("dup\n");
    32483248      }
    32493249      cvtFunction(shading->getFunc(i));
    32503250      writePS("exec\n");
    32513251      if (i < shading->getNFuncs() - 1) {
    3252     writePS("exch\n");
     3252        writePS("exch\n");
    32533253      }
    32543254    }
     
    32893289      y3 = subpath->getY(3);
    32903290      if (x0 == x1 && x2 == x3 && y0 == y3 && y1 == y2) {
    3291     writePSFmt("%g %g %g %g re\n",
    3292            x0 < x2 ? x0 : x2, y0 < y1 ? y0 : y1,
    3293            fabs(x2 - x0), fabs(y1 - y0));
    3294     return;
     3291        writePSFmt("%g %g %g %g re\n",
     3292                   x0 < x2 ? x0 : x2, y0 < y1 ? y0 : y1,
     3293                   fabs(x2 - x0), fabs(y1 - y0));
     3294        return;
    32953295      } else if (x0 == x3 && x1 == x2 && y0 == y1 && y2 == y3) {
    3296     writePSFmt("%g %g %g %g re\n",
    3297            x0 < x1 ? x0 : x1, y0 < y2 ? y0 : y2,
    3298            fabs(x1 - x0), fabs(y2 - y0));
    3299     return;
     3296        writePSFmt("%g %g %g %g re\n",
     3297                   x0 < x1 ? x0 : x1, y0 < y2 ? y0 : y2,
     3298                   fabs(x1 - x0), fabs(y2 - y0));
     3299        return;
    33003300      }
    33013301    }
     
    33093309    while (j < m) {
    33103310      if (subpath->getCurve(j)) {
    3311     writePSFmt("%g %g %g %g %g %g c\n", subpath->getX(j), subpath->getY(j),
    3312            subpath->getX(j+1), subpath->getY(j+1),
    3313            subpath->getX(j+2), subpath->getY(j+2));
    3314     j += 3;
     3311        writePSFmt("%g %g %g %g %g %g c\n", subpath->getX(j), subpath->getY(j),
     3312                   subpath->getX(j+1), subpath->getY(j+1),
     3313                   subpath->getX(j+2), subpath->getY(j+2));
     3314        j += 3;
    33153315      } else {
    3316     writePSFmt("%g %g l\n", subpath->getX(j), subpath->getY(j));
    3317     ++j;
     3316        writePSFmt("%g %g l\n", subpath->getX(j), subpath->getY(j));
     3317        ++j;
    33183318      }
    33193319    }
     
    33573357    for (i = 0; i < font16EncLen; ++i) {
    33583358      if (font->getID()->num == font16Enc[i].fontID.num &&
    3359       font->getID()->gen == font16Enc[i].fontID.gen) {
    3360     uMap = globalParams->getUnicodeMap(font16Enc[i].enc);
    3361     break;
     3359          font->getID()->gen == font16Enc[i].fontID.gen) {
     3360        uMap = globalParams->getUnicodeMap(font16Enc[i].enc);
     3361        break;
    33623362      }
    33633363    }
     
    33783378  while (len > 0) {
    33793379    n = font->getNextChar(p, len, &code,
    3380               u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
    3381               &dx2, &dy2, &originX, &originY);
     3380                          u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
     3381                          &dx2, &dy2, &originX, &originY);
    33823382    if (font->isCIDFont()) {
    33833383      if (uMap) {
    3384     for (i = 0; i < uLen; ++i) {
    3385       m = uMap->mapUnicode(u[i], buf, (int)sizeof(buf));
    3386       for (j = 0; j < m; ++j) {
    3387         s2->append(buf[j]);
    3388       }
    3389     }
    3390     //~ this really needs to get the number of chars in the target
    3391     //~ encoding - which may be more than the number of Unicode
    3392     //~ chars
    3393     nChars += uLen;
     3384        for (i = 0; i < uLen; ++i) {
     3385          m = uMap->mapUnicode(u[i], buf, (int)sizeof(buf));
     3386          for (j = 0; j < m; ++j) {
     3387            s2->append(buf[j]);
     3388          }
     3389        }
     3390        //~ this really needs to get the number of chars in the target
     3391        //~ encoding - which may be more than the number of Unicode
     3392        //~ chars
     3393        nChars += uLen;
    33943394      } else {
    3395     s2->append((char)((code >> 8) & 0xff));
    3396     s2->append((char)(code & 0xff));
    3397     ++nChars;
     3395        s2->append((char)((code >> 8) & 0xff));
     3396        s2->append((char)(code & 0xff));
     3397        ++nChars;
    33983398      }
    33993399    }
     
    34133413    if (font->isCIDFont()) {
    34143414      if (wMode) {
    3415     writePSFmt(" %d %g Tj16V\n", nChars, dy);
     3415        writePSFmt(" %d %g Tj16V\n", nChars, dy);
    34163416      } else {
    3417     writePSFmt(" %d %g Tj16\n", nChars, dx);
     3417        writePSFmt(" %d %g Tj16\n", nChars, dx);
    34183418      }
    34193419    } else {
     
    34383438
    34393439void PSOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
    3440                 int width, int height, GBool invert,
    3441                 GBool inlineImg) {
     3440                                int width, int height, GBool invert,
     3441                                GBool inlineImg) {
    34423442  int len;
    34433443
     
    34473447  } else {
    34483448    doImageL2(ref, NULL, invert, inlineImg, str, width, height, len,
    3449           NULL, NULL, 0, 0, gFalse);
     3449              NULL, NULL, 0, 0, gFalse);
    34503450  }
    34513451}
    34523452
    34533453void PSOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
    3454                 int width, int height, GfxImageColorMap *colorMap,
    3455                 int *maskColors, GBool inlineImg) {
     3454                            int width, int height, GfxImageColorMap *colorMap,
     3455                            int *maskColors, GBool inlineImg) {
    34563456  int len;
    34573457
    34583458  len = height * ((width * colorMap->getNumPixelComps() *
    3459            colorMap->getBits() + 7) / 8);
     3459                   colorMap->getBits() + 7) / 8);
    34603460  switch (level) {
    34613461  case psLevel1:
     
    34713471  case psLevel3Sep:
    34723472    doImageL2(ref, colorMap, gFalse, inlineImg, str,
    3473           width, height, len, maskColors, NULL, 0, 0, gFalse);
     3473              width, height, len, maskColors, NULL, 0, 0, gFalse);
    34743474    break;
    34753475  }
     
    34783478
    34793479void PSOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
    3480                   int width, int height,
    3481                   GfxImageColorMap *colorMap,
    3482                   Stream *maskStr,
    3483                   int maskWidth, int maskHeight,
    3484                   GBool maskInvert) {
     3480                                  int width, int height,
     3481                                  GfxImageColorMap *colorMap,
     3482                                  Stream *maskStr,
     3483                                  int maskWidth, int maskHeight,
     3484                                  GBool maskInvert) {
    34853485  int len;
    34863486
    34873487  len = height * ((width * colorMap->getNumPixelComps() *
    3488            colorMap->getBits() + 7) / 8);
     3488                   colorMap->getBits() + 7) / 8);
    34893489  switch (level) {
    34903490  case psLevel1:
     
    35003500  case psLevel3Sep:
    35013501    doImageL2(ref, colorMap, gFalse, gFalse, str, width, height, len,
    3502           NULL, maskStr, maskWidth, maskHeight, maskInvert);
     3502              NULL, maskStr, maskWidth, maskHeight, maskInvert);
    35033503    break;
    35043504  }
     
    35073507
    35083508void PSOutputDev::doImageL1(Object *ref, GfxImageColorMap *colorMap,
    3509                 GBool invert, GBool inlineImg,
    3510                 Stream *str, int width, int height, int len) {
     3509                            GBool invert, GBool inlineImg,
     3510                            Stream *str, int width, int height, int len) {
    35113511  ImageStream *imgStr;
    35123512  Guchar pixBuf[gfxColorMaxComps];
     
    35233523      writePS("[<");
    35243524      do {
    3525     do {
    3526       c = str->getChar();
    3527     } while (c == '\n' || c == '\r');
    3528     if (c == '>' || c == EOF) {
    3529       break;
    3530     }
    3531     writePSChar(c);
    3532     ++col;
    3533     // each line is: "<...data...><eol>"
    3534     // so max data length = 255 - 4 = 251
    3535     // but make it 240 just to be safe
    3536     // chunks are 2 bytes each, so we need to stop on an even col number
    3537     if (col == 240) {
    3538       writePS(">\n<");
    3539       col = 0;
    3540     }
     3525        do {
     3526          c = str->getChar();
     3527        } while (c == '\n' || c == '\r');
     3528        if (c == '>' || c == EOF) {
     3529          break;
     3530        }
     3531        writePSChar(c);
     3532        ++col;
     3533        // each line is: "<...data...><eol>"
     3534        // so max data length = 255 - 4 = 251
     3535        // but make it 240 just to be safe
     3536        // chunks are 2 bytes each, so we need to stop on an even col number
     3537        if (col == 240) {
     3538          writePS(">\n<");
     3539          col = 0;
     3540        }
    35413541      } while (c != '>' && c != EOF);
    35423542      writePS(">]\n");
     
    35533553  if (inType3Char && !colorMap) {
    35543554    writePSFmt("%d %d %s [%d 0 0 %d 0 %d] pdfImM1a\n",
    3555            width, height, invert ? "true" : "false",
    3556            width, -height, height);
     3555               width, height, invert ? "true" : "false",
     3556               width, -height, height);
    35573557  } else if (colorMap) {
    35583558    writePSFmt("%d %d 8 [%d 0 0 %d 0 %d] pdfIm1\n",
    3559            width, height,
    3560            width, -height, height);
     3559               width, height,
     3560               width, -height, height);
    35613561  } else {
    35623562    writePSFmt("%d %d %s [%d 0 0 %d 0 %d] pdfImM1\n",
    3563            width, height, invert ? "true" : "false",
    3564            width, -height, height);
     3563               width, height, invert ? "true" : "false",
     3564               width, -height, height);
    35653565  }
    35663566
     
    35723572      // set up to process the data stream
    35733573      imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    3574                    colorMap->getBits());
     3574                               colorMap->getBits());
    35753575      imgStr->reset();
    35763576
     
    35793579      for (y = 0; y < height; ++y) {
    35803580
    3581     // write the line
    3582     for (x = 0; x < width; ++x) {
    3583       imgStr->getPixel(pixBuf);
    3584       colorMap->getGray(pixBuf, &gray);
    3585       writePSFmt("%02x", colToByte(gray));
    3586       if (++i == 32) {
    3587         writePSChar('\n');
    3588         i = 0;
    3589       }
    3590     }
     3581        // write the line
     3582        for (x = 0; x < width; ++x) {
     3583          imgStr->getPixel(pixBuf);
     3584          colorMap->getGray(pixBuf, &gray);
     3585          writePSFmt("%02x", colToByte(gray));
     3586          if (++i == 32) {
     3587            writePSChar('\n');
     3588            i = 0;
     3589          }
     3590        }
    35913591      }
    35923592      if (i != 0) {
    3593     writePSChar('\n');
     3593        writePSChar('\n');
    35943594      }
    35953595      delete imgStr;
     
    36003600      i = 0;
    36013601      for (y = 0; y < height; ++y) {
    3602     for (x = 0; x < width; x += 8) {
    3603       writePSFmt("%02x", str->getChar() & 0xff);
    3604       if (++i == 32) {
    3605         writePSChar('\n');
    3606         i = 0;
    3607       }
    3608     }
     3602        for (x = 0; x < width; x += 8) {
     3603          writePSFmt("%02x", str->getChar() & 0xff);
     3604          if (++i == 32) {
     3605            writePSChar('\n');
     3606            i = 0;
     3607          }
     3608        }
    36093609      }
    36103610      if (i != 0) {
    3611     writePSChar('\n');
     3611        writePSChar('\n');
    36123612      }
    36133613      str->close();
     
    36173617
    36183618void PSOutputDev::doImageL1Sep(GfxImageColorMap *colorMap,
    3619                    GBool invert, GBool inlineImg,
    3620                    Stream *str, int width, int height, int len) {
     3619                               GBool invert, GBool inlineImg,
     3620                               Stream *str, int width, int height, int len) {
    36213621  ImageStream *imgStr;
    36223622  Guchar *lineBuf;
     
    36273627  // width, height, matrix, bits per component
    36283628  writePSFmt("%d %d 8 [%d 0 0 %d 0 %d] pdfIm1Sep\n",
    3629          width, height,
    3630          width, -height, height);
     3629             width, height,
     3630             width, -height, height);
    36313631
    36323632  // allocate a line buffer
     
    36353635  // set up to process the data stream
    36363636  imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    3637                colorMap->getBits());
     3637                           colorMap->getBits());
    36383638  imgStr->reset();
    36393639
     
    36513651      lineBuf[4*x+3] = colToByte(cmyk.k);
    36523652      addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    3653               colToDbl(cmyk.y), colToDbl(cmyk.k));
     3653                      colToDbl(cmyk.y), colToDbl(cmyk.k));
    36543654    }
    36553655
     
    36573657    for (comp = 0; comp < 4; ++comp) {
    36583658      for (x = 0; x < width; ++x) {
    3659     writePSFmt("%02x", lineBuf[4*x + comp]);
    3660     if (++i == 32) {
    3661       writePSChar('\n');
    3662       i = 0;
    3663     }
     3659        writePSFmt("%02x", lineBuf[4*x + comp]);
     3660        if (++i == 32) {
     3661          writePSChar('\n');
     3662          i = 0;
     3663        }
    36643664      }
    36653665    }
     
    36753675
    36763676void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
    3677                 GBool invert, GBool inlineImg,
    3678                 Stream *str, int width, int height, int len,
    3679                 int *maskColors, Stream *maskStr,
    3680                 int maskWidth, int maskHeight, GBool maskInvert) {
     3677                            GBool invert, GBool inlineImg,
     3678                            Stream *str, int width, int height, int len,
     3679                            int *maskColors, Stream *maskStr,
     3680                            int maskWidth, int maskHeight, GBool maskInvert) {
    36813681  ImageStream *imgStr;
    36823682  Guchar *line, *pix;
     
    37003700    for (y = 0, y0 = 0; y < height; ++y) {
    37013701      if (!(line = imgStr->getLine())) {
    3702     break;
     3702        break;
    37033703      }
    37043704      for (x = 0, x0 = 0, pix = line; x < width; ++x, pix += numComps) {
    3705     for (i = 0; i < numComps; ++i) {
    3706       if (pix[i] < maskColors[2*i] ||
    3707           pix[i] > maskColors[2*i+1]) {
    3708         break;
    3709       }
    3710     }
    3711     if (i == numComps) {
    3712       if (y0 < y) {
    3713         writePSFmt("0 %d %d %d\n", height - y, width, y - y0);
    3714       }
    3715       if (x0 < x) {
    3716         writePSFmt("%d %d %d 1\n", x0, height - y - 1, x - x0);
    3717       }
    3718       x0 = x + 1;
    3719       y0 = y + 1;
    3720     }
     3705        for (i = 0; i < numComps; ++i) {
     3706          if (pix[i] < maskColors[2*i] ||
     3707              pix[i] > maskColors[2*i+1]) {
     3708            break;
     3709          }
     3710        }
     3711        if (i == numComps) {
     3712          if (y0 < y) {
     3713            writePSFmt("0 %d %d %d\n", height - y, width, y - y0);
     3714          }
     3715          if (x0 < x) {
     3716            writePSFmt("%d %d %d 1\n", x0, height - y - 1, x - x0);
     3717          }
     3718          x0 = x + 1;
     3719          y0 = y + 1;
     3720        }
    37213721      }
    37223722      if (x0 > 0 && x0 < width) {
    3723     writePSFmt("%d %d %d 1\n", x0, height - y - 1, width - x0);
     3723        writePSFmt("%d %d %d 1\n", x0, height - y - 1, width - x0);
    37243724      }
    37253725    }
     
    37393739    for (y = 0, y0 = 0; y < maskHeight; ++y) {
    37403740      if (!(line = imgStr->getLine())) {
    3741     break;
     3741        break;
    37423742      }
    37433743      for (x = 0, x0 = 0, pix = line; x < maskWidth; ++x, ++pix) {
    3744     if (*pix ^ maskXor) {
    3745       if (y0 < y) {
    3746         writePSFmt("0 %d %d %d\n", maskHeight - y, maskWidth, y - y0);
    3747       }
    3748       if (x0 < x) {
    3749         writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, x - x0);
    3750       }
    3751       x0 = x + 1;
    3752       y0 = y + 1;
    3753     }
     3744        if (*pix ^ maskXor) {
     3745          if (y0 < y) {
     3746            writePSFmt("0 %d %d %d\n", maskHeight - y, maskWidth, y - y0);
     3747          }
     3748          if (x0 < x) {
     3749            writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, x - x0);
     3750          }
     3751          x0 = x + 1;
     3752          y0 = y + 1;
     3753        }
    37543754      }
    37553755      if (x0 > 0 && x0 < maskWidth) {
    3756     writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, maskWidth - x0);
     3756        writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, maskWidth - x0);
    37573757      }
    37583758    }
     
    37793779      str = new FixedLengthEncoder(str, len);
    37803780      if (useASCIIHex) {
    3781     str = new ASCIIHexEncoder(str);
     3781        str = new ASCIIHexEncoder(str);
    37823782      } else {
    3783     str = new ASCII85Encoder(str);
     3783        str = new ASCII85Encoder(str);
    37843784      }
    37853785      str->reset();
     
    37873787      writePS((char *)(useASCIIHex ? "[<" : "[<~"));
    37883788      do {
    3789     do {
    3790       c = str->getChar();
    3791     } while (c == '\n' || c == '\r');
    3792     if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    3793       break;
    3794     }
    3795     if (c == 'z') {
    3796       writePSChar(c);
    3797       ++col;
    3798     } else {
    3799       writePSChar(c);
    3800       ++col;
    3801       for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    3802         do {
    3803           c = str->getChar();
    3804         } while (c == '\n' || c == '\r');
    3805         if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    3806           break;
    3807         }
    3808         writePSChar(c);
    3809         ++col;
    3810       }
    3811     }
    3812     // each line is: "<~...data...~><eol>"
    3813     // so max data length = 255 - 6 = 249
    3814     // chunks are 1 or 5 bytes each, so we have to stop at 245
    3815     // but make it 240 just to be safe
    3816     if (col > 240) {
    3817       writePS((char *)(useASCIIHex ? ">\n<" : "~>\n<~"));
    3818       col = 0;
    3819     }
     3789        do {
     3790          c = str->getChar();
     3791        } while (c == '\n' || c == '\r');
     3792        if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     3793          break;
     3794        }
     3795        if (c == 'z') {
     3796          writePSChar(c);
     3797          ++col;
     3798        } else {
     3799          writePSChar(c);
     3800          ++col;
     3801          for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
     3802            do {
     3803              c = str->getChar();
     3804            } while (c == '\n' || c == '\r');
     3805            if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     3806              break;
     3807            }
     3808            writePSChar(c);
     3809            ++col;
     3810          }
     3811        }
     3812        // each line is: "<~...data...~><eol>"
     3813        // so max data length = 255 - 6 = 249
     3814        // chunks are 1 or 5 bytes each, so we have to stop at 245
     3815        // but make it 240 just to be safe
     3816        if (col > 240) {
     3817          writePS((char *)(useASCIIHex ? ">\n<" : "~>\n<~"));
     3818          col = 0;
     3819        }
    38203820      } while (c != (useASCIIHex ? '>' : '~') && c != EOF);
    38213821      writePS((char *)(useASCIIHex ? ">]\n" : "~>]\n"));
     
    38403840  } else {
    38413841    writePSFmt("  /BitsPerComponent %d\n",
    3842            colorMap ? colorMap->getBits() : 1);
    3843   }
    3844 
    3845   // decode
     3842               colorMap ? colorMap->getBits() : 1);
     3843  }
     3844
     3845  // decode 
    38463846  if (colorMap) {
    38473847    writePS("  /Decode [");
    38483848    if ((level == psLevel2Sep || level == psLevel3Sep) &&
    3849     colorMap->getColorSpace()->getMode() == csSeparation) {
     3849        colorMap->getColorSpace()->getMode() == csSeparation) {
    38503850      // this matches up with the code in the pdfImSep operator
    38513851      n = (1 << colorMap->getBits()) - 1;
    38523852      writePSFmt("%g %g", colorMap->getDecodeLow(0) * n,
    3853         colorMap->getDecodeHigh(0) * n);
     3853                colorMap->getDecodeHigh(0) * n);
    38543854    } else if (colorMap->getColorSpace()->getMode() == csDeviceN) {
    38553855      numComps = ((GfxDeviceNColorSpace *)colorMap->getColorSpace())->
    3856                getAlt()->getNComps();
     3856                   getAlt()->getNComps();
    38573857      for (i = 0; i < numComps; ++i) {
    3858     if (i > 0) {
    3859       writePS(" ");
    3860     }
    3861     writePS("0 1");
     3858        if (i > 0) {
     3859          writePS(" ");
     3860        }
     3861        writePS("0 1");
    38623862      }
    38633863    } else {
    38643864      numComps = colorMap->getNumPixelComps();
    38653865      for (i = 0; i < numComps; ++i) {
    3866     if (i > 0) {
    3867       writePS(" ");
    3868     }
    3869     writePSFmt("%g %g", colorMap->getDecodeLow(i),
    3870            colorMap->getDecodeHigh(i));
     3866        if (i > 0) {
     3867          writePS(" ");
     3868        }
     3869        writePSFmt("%g %g", colorMap->getDecodeLow(i),
     3870                   colorMap->getDecodeHigh(i));
    38713871      }
    38723872    }
     
    38923892    writePS("  /DataSource currentfile\n");
    38933893    s = str->getPSFilter(level < psLevel2 ? 1 : level < psLevel3 ? 2 : 3,
    3894             "    ");
     3894                        "    ");
    38953895    if ((colorMap && colorMap->getColorSpace()->getMode() == csDeviceN) ||
    3896     inlineImg || !s) {
     3896        inlineImg || !s) {
    38973897      useRLE = gTrue;
    38983898      useASCII = gTrue;
     
    39053905    if (useASCII) {
    39063906      writePSFmt("    /ASCII%sDecode filter\n",
    3907         useASCIIHex ? "Hex" : "85");
     3907                useASCIIHex ? "Hex" : "85");
    39083908    }
    39093909    if (useRLE) {
     
    39353935    if (useASCII) {
    39363936      if (useASCIIHex) {
    3937     str = new ASCIIHexEncoder(str);
     3937        str = new ASCIIHexEncoder(str);
    39383938      } else {
    3939     str = new ASCII85Encoder(str);
     3939        str = new ASCII85Encoder(str);
    39403940      }
    39413941    }
     
    39463946    if (opi13Nest) {
    39473947      if (inlineImg) {
    3948     // this can't happen -- OPI dictionaries are in XObjects
    3949     error(-1, "Internal: OPI in inline image");
    3950     n = 0;
     3948        // this can't happen -- OPI dictionaries are in XObjects
     3949        error(-1, "Internal: OPI in inline image");
     3950        n = 0;
    39513951      } else {
    3952     // need to read the stream to count characters -- the length
    3953     // is data-dependent (because of ASCII and RLE filters)
    3954     str->reset();
    3955     n = 0;
    3956     while ((c = str->getChar()) != EOF) {
    3957       ++n;
    3958     }
    3959     str->close();
     3952        // need to read the stream to count characters -- the length
     3953        // is data-dependent (because of ASCII and RLE filters)
     3954        str->reset();
     3955        n = 0;
     3956        while ((c = str->getChar()) != EOF) {
     3957          ++n;
     3958        }
     3959        str->close();
    39603960      }
    39613961      // +6/7 for "pdfIm\n" / "pdfImM\n"
     
    39663966#endif
    39673967    if ((level == psLevel2Sep || level == psLevel3Sep) && colorMap &&
    3968     colorMap->getColorSpace()->getMode() == csSeparation) {
     3968        colorMap->getColorSpace()->getMode() == csSeparation) {
    39693969      color.c[0] = gfxColorComp1;
    39703970      sepCS = (GfxSeparationColorSpace *)colorMap->getColorSpace();
    39713971      sepCS->getCMYK(&color, &cmyk);
    39723972      writePSFmt("%g %g %g %g (%s) pdfImSep\n",
    3973         colToDbl(cmyk.c), colToDbl(cmyk.m),
    3974         colToDbl(cmyk.y), colToDbl(cmyk.k),
    3975         sepCS->getName()->getCString());
     3973                colToDbl(cmyk.c), colToDbl(cmyk.m),
     3974                colToDbl(cmyk.y), colToDbl(cmyk.k),
     3975                sepCS->getName()->getCString());
    39763976    } else {
    39773977      writePSFmt("%s\n", colorMap ? "pdfIm" : "pdfImM");
     
    40064006
    40074007void PSOutputDev::dumpColorSpaceL2(GfxColorSpace *colorSpace,
    4008                    GBool genXform, GBool updateColors) {
     4008                                   GBool genXform, GBool updateColors) {
    40094009  GfxCalGrayColorSpace *calGrayCS;
    40104010  GfxCalRGBColorSpace *calRGBCS;
     
    40404040    writePSFmt(" /DecodeA {%g exp} bind\n", calGrayCS->getGamma());
    40414041    writePSFmt(" /MatrixA [%g %g %g]\n",
    4042            calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
    4043            calGrayCS->getWhiteZ());
     4042               calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
     4043               calGrayCS->getWhiteZ());
    40444044    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4045            calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
    4046            calGrayCS->getWhiteZ());
     4045               calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
     4046               calGrayCS->getWhiteZ());
    40474047    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4048            calGrayCS->getBlackX(), calGrayCS->getBlackY(),
    4049            calGrayCS->getBlackZ());
     4048               calGrayCS->getBlackX(), calGrayCS->getBlackY(),
     4049               calGrayCS->getBlackZ());
    40504050    writePS(">>]");
    40514051    if (genXform) {
     
    40714071    writePS("[/CIEBasedABC <<\n");
    40724072    writePSFmt(" /DecodeABC [{%g exp} bind {%g exp} bind {%g exp} bind]\n",
    4073            calRGBCS->getGammaR(), calRGBCS->getGammaG(),
    4074            calRGBCS->getGammaB());
     4073               calRGBCS->getGammaR(), calRGBCS->getGammaG(),
     4074               calRGBCS->getGammaB());
    40754075    writePSFmt(" /MatrixABC [%g %g %g %g %g %g %g %g %g]\n",
    4076            calRGBCS->getMatrix()[0], calRGBCS->getMatrix()[1],
    4077            calRGBCS->getMatrix()[2], calRGBCS->getMatrix()[3],
    4078            calRGBCS->getMatrix()[4], calRGBCS->getMatrix()[5],
    4079            calRGBCS->getMatrix()[6], calRGBCS->getMatrix()[7],
    4080            calRGBCS->getMatrix()[8]);
     4076               calRGBCS->getMatrix()[0], calRGBCS->getMatrix()[1],
     4077               calRGBCS->getMatrix()[2], calRGBCS->getMatrix()[3],
     4078               calRGBCS->getMatrix()[4], calRGBCS->getMatrix()[5],
     4079               calRGBCS->getMatrix()[6], calRGBCS->getMatrix()[7],
     4080               calRGBCS->getMatrix()[8]);
    40814081    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4082            calRGBCS->getWhiteX(), calRGBCS->getWhiteY(),
    4083            calRGBCS->getWhiteZ());
     4082               calRGBCS->getWhiteX(), calRGBCS->getWhiteY(),
     4083               calRGBCS->getWhiteZ());
    40844084    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4085            calRGBCS->getBlackX(), calRGBCS->getBlackY(),
    4086            calRGBCS->getBlackZ());
     4085               calRGBCS->getBlackX(), calRGBCS->getBlackY(),
     4086               calRGBCS->getBlackZ());
    40874087    writePS(">>]");
    40884088    if (genXform) {
     
    41084108    writePS("[/CIEBasedABC <<\n");
    41094109    writePSFmt(" /RangeABC [0 100 %g %g %g %g]\n",
    4110            labCS->getAMin(), labCS->getAMax(),
    4111            labCS->getBMin(), labCS->getBMax());
     4110               labCS->getAMin(), labCS->getAMax(),
     4111               labCS->getBMin(), labCS->getBMax());
    41124112    writePS(" /DecodeABC [{16 add 116 div} bind {500 div} bind {200 div} bind]\n");
    41134113    writePS(" /MatrixABC [1 1 1 1 0 0 0 0 -1]\n");
     
    41154115    writePS("   [{dup 6 29 div ge {dup dup mul mul}\n");
    41164116    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind\n",
    4117            labCS->getWhiteX());
     4117               labCS->getWhiteX());
    41184118    writePS("    {dup 6 29 div ge {dup dup mul mul}\n");
    41194119    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind\n",
    4120            labCS->getWhiteY());
     4120               labCS->getWhiteY());
    41214121    writePS("    {dup 6 29 div ge {dup dup mul mul}\n");
    41224122    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind]\n",
    4123            labCS->getWhiteZ());
     4123               labCS->getWhiteZ());
    41244124    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4125            labCS->getWhiteX(), labCS->getWhiteY(), labCS->getWhiteZ());
     4125               labCS->getWhiteX(), labCS->getWhiteY(), labCS->getWhiteZ());
    41264126    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4127            labCS->getBlackX(), labCS->getBlackY(), labCS->getBlackZ());
     4127               labCS->getBlackX(), labCS->getBlackY(), labCS->getBlackZ());
    41284128    writePS(">>]");
    41294129    if (genXform) {
     
    41394139    // we can use it directly
    41404140    dumpColorSpaceL2(((GfxICCBasedColorSpace *)colorSpace)->getAlt(),
    4141              genXform, updateColors);
     4141                     genXform, updateColors);
    41424142    break;
    41434143
     
    41564156      p = lookup;
    41574157      for (i = 0; i <= n; i += 8) {
    4158     writePS("  ");
    4159     for (j = i; j < i+8 && j <= n; ++j) {
    4160       for (k = 0; k < numComps; ++k) {
    4161         x[k] = *p++ / 255.0;
    4162       }
    4163       func->transform(x, y);
    4164       for (k = 0; k < numAltComps; ++k) {
    4165         byte = (int)(y[k] * 255 + 0.5);
    4166         if (byte < 0) {
    4167           byte = 0;
    4168         } else if (byte > 255) {
    4169           byte = 255;
    4170         }
    4171         writePSFmt("%02x", byte);
    4172       }
    4173       if (updateColors) {
    4174         color.c[0] = dblToCol(j);
    4175       indexedCS->getCMYK(&color, &cmyk);
    4176         addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    4177                 colToDbl(cmyk.y), colToDbl(cmyk.k));
    4178       }
    4179     }
    4180     writePS("\n");
     4158        writePS("  ");
     4159        for (j = i; j < i+8 && j <= n; ++j) {
     4160          for (k = 0; k < numComps; ++k) {
     4161            x[k] = *p++ / 255.0;
     4162          }
     4163          func->transform(x, y);
     4164          for (k = 0; k < numAltComps; ++k) {
     4165            byte = (int)(y[k] * 255 + 0.5);
     4166            if (byte < 0) {
     4167              byte = 0;
     4168            } else if (byte > 255) {
     4169              byte = 255;
     4170            }
     4171            writePSFmt("%02x", byte);
     4172          }
     4173          if (updateColors) {
     4174            color.c[0] = dblToCol(j);
     4175          indexedCS->getCMYK(&color, &cmyk);
     4176            addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
     4177                            colToDbl(cmyk.y), colToDbl(cmyk.k));
     4178          }
     4179        }
     4180        writePS("\n");
    41814181      }
    41824182    } else {
    41834183      for (i = 0; i <= n; i += 8) {
    4184     writePS("  ");
    4185     for (j = i; j < i+8 && j <= n; ++j) {
    4186       for (k = 0; k < numComps; ++k) {
    4187         writePSFmt("%02x", lookup[j * numComps + k]);
    4188       }
    4189       if (updateColors) {
    4190         color.c[0] = dblToCol(j);
    4191       indexedCS->getCMYK(&color, &cmyk);
    4192         addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    4193                 colToDbl(cmyk.y), colToDbl(cmyk.k));
    4194       }
    4195     }
    4196     writePS("\n");
     4184        writePS("  ");
     4185        for (j = i; j < i+8 && j <= n; ++j) {
     4186          for (k = 0; k < numComps; ++k) {
     4187            writePSFmt("%02x", lookup[j * numComps + k]);
     4188          }
     4189          if (updateColors) {
     4190            color.c[0] = dblToCol(j);
     4191          indexedCS->getCMYK(&color, &cmyk);
     4192            addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
     4193                            colToDbl(cmyk.y), colToDbl(cmyk.k));
     4194          }
     4195        }
     4196        writePS("\n");
    41974197      }
    41984198    }
     
    42494249      opiDict->lookup("1.3", &dict);
    42504250      if (dict.isDict()) {
    4251     opiBegin13(state, dict.getDict());
     4251        opiBegin13(state, dict.getDict());
    42524252      }
    42534253      dict.free();
     
    42684268  if (getFileSpec(&obj1, &obj2)) {
    42694269    writePSFmt("%%%%ImageFileName: %s\n",
    4270            obj2.getString()->getCString());
     4270               obj2.getString()->getCString());
    42714271    obj2.free();
    42724272  }
     
    43254325    if (obj2.isName()) {
    43264326      writePSFmt("%%%%ImageInks: %s %d",
    4327         obj2.getName(), (obj1.arrayGetLength() - 1) / 2);
     4327                obj2.getName(), (obj1.arrayGetLength() - 1) / 2);
    43284328      for (i = 1; i+1 < obj1.arrayGetLength(); i += 2) {
    4329     obj1.arrayGet(i, &obj3);
    4330     obj1.arrayGet(i+1, &obj4);
    4331     if (obj3.isString() && obj4.isNum()) {
    4332       writePS(" ");
    4333       writePSString(obj3.getString());
    4334       writePSFmt(" %g", obj4.getNum());
    4335     }
    4336     obj3.free();
    4337     obj4.free();
     4329        obj1.arrayGet(i, &obj3);
     4330        obj1.arrayGet(i+1, &obj4);
     4331        if (obj3.isString() && obj4.isNum()) {
     4332          writePS(" ");
     4333          writePSString(obj3.getString());
     4334          writePSFmt(" %g", obj4.getNum());
     4335        }
     4336        obj3.free();
     4337        obj4.free();
    43384338      }
    43394339      writePS("\n");
     
    43844384  if (getFileSpec(&obj1, &obj2)) {
    43854385    writePSFmt("%%ALDImageFileName: %s\n",
    4386            obj2.getString()->getCString());
     4386               obj2.getString()->getCString());
    43874387    obj2.free();
    43884388  }
     
    44634463    for (i = 0; i < obj1.arrayGetLength(); i += 16) {
    44644464      if (i > 0) {
    4465     writePS("\n%%+");
     4465        writePS("\n%%+");
    44664466      }
    44674467      for (j = 0; j < 16 && i+j < obj1.arrayGetLength(); ++j) {
    4468     obj1.arrayGet(i+j, &obj2);
    4469     writePSFmt(" %d", obj2.getInt());
    4470     obj2.free();
     4468        obj1.arrayGet(i+j, &obj2);
     4469        writePSFmt(" %d", obj2.getInt());
     4470        obj2.free();
    44714471      }
    44724472    }
     
    45304530    opiTransform(state, lrx, lry, &tlrx, &tlry);
    45314531    writePSFmt("%%ALDImagePosition: %g %g %g %g %g %g %g %g\n",
    4532            tllx, tlly, tulx, tuly, turx, tury, tlrx, tlry);
     4532               tllx, tlly, tulx, tuly, turx, tury, tlrx, tlry);
    45334533    obj2.free();
    45344534  }
     
    45844584// PSOutputDev page-fitting transform.
    45854585void PSOutputDev::opiTransform(GfxState *state, double x0, double y0,
    4586                    double *x1, double *y1) {
     4586                               double *x1, double *y1) {
    45874587  double t;
    45884588
     
    46214621      opiDict->lookup("1.3", &dict);
    46224622      if (dict.isDict()) {
    4623     writePS("%%EndObject\n");
    4624     writePS("restore\n");
    4625     --opi13Nest;
     4623        writePS("%%EndObject\n");
     4624        writePS("restore\n");
     4625        --opi13Nest;
    46264626      }
    46274627      dict.free();
     
    46674667
    46684668void PSOutputDev::type3D1(GfxState *state, double wx, double wy,
    4669               double llx, double lly, double urx, double ury) {
     4669                          double llx, double lly, double urx, double ury) {
    46704670  t3WX = wx;
    46714671  t3WY = wy;
     
    47064706  switch (func->getType()) {
    47074707
    4708   case -1:          // identity
     4708  case -1:                      // identity
    47094709    writePS("{}\n");
    47104710    break;
    47114711
    4712   case 0:           // sampled
     4712  case 0:                       // sampled
    47134713    func0 = (SampledFunction *)func;
    47144714    thisFunc = nextFunc++;
     
    47294729      // [e01] [efrac] x0 x1 ... xi
    47304730      writePSFmt("%g sub %g mul %g add\n",
    4731           func0->getDomainMin(i),
    4732           (func0->getEncodeMax(i) - func0->getEncodeMin(i)) /
    4733             (func0->getDomainMax(i) - func0->getDomainMin(i)),
    4734           func0->getEncodeMin(i));
     4731              func0->getDomainMin(i),
     4732              (func0->getEncodeMax(i) - func0->getEncodeMin(i)) /
     4733                (func0->getDomainMax(i) - func0->getDomainMin(i)),
     4734              func0->getEncodeMin(i));
    47354735      // [e01] [efrac] x0 x1 ... xi-1 xi'
    47364736      writePSFmt("dup 0 lt { pop 0 } { dup %d gt { pop %d } if } ifelse\n",
    4737         func0->getSampleSize(i) - 1, func0->getSampleSize(i) - 1);
     4737                func0->getSampleSize(i) - 1, func0->getSampleSize(i) - 1);
    47384738      // [e01] [efrac] x0 x1 ... xi-1 xi'
    47394739      writePS("dup floor cvi exch dup ceiling cvi exch 2 index sub\n");
     
    47504750      // [e01] [efrac] y(0) ... y(i-1)
    47514751      for (j = 0; j < (1<<m); ++j) {
    4752     // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(j-1)
    4753     writePSFmt("xpdfSamples%d\n", thisFunc);
    4754     k = m - 1;
    4755     writePSFmt("%d index %d get\n", i+j+2, 2 * k + ((j >> k) & 1));
    4756     for (k = m - 2; k >= 0; --k) {
    4757       writePSFmt("%d mul %d index %d get add\n",
    4758              func0->getSampleSize(k),
    4759              i + j + 3,
    4760              2 * k + ((j >> k) & 1));
    4761     }
    4762     if (n > 1) {
    4763       writePSFmt("%d mul %d add ", n, i);
    4764     }
    4765     writePS("get\n");
     4752        // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(j-1)
     4753        writePSFmt("xpdfSamples%d\n", thisFunc);
     4754        k = m - 1;
     4755        writePSFmt("%d index %d get\n", i+j+2, 2 * k + ((j >> k) & 1));
     4756        for (k = m - 2; k >= 0; --k) {
     4757          writePSFmt("%d mul %d index %d get add\n",
     4758                     func0->getSampleSize(k),
     4759                     i + j + 3,
     4760                     2 * k + ((j >> k) & 1));
     4761        }
     4762        if (n > 1) {
     4763          writePSFmt("%d mul %d add ", n, i);
     4764        }
     4765        writePS("get\n");
    47664766      }
    47674767      // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^m-1)
    47684768      for (j = 0; j < m; ++j) {
    4769     // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^(m-j)-1)
    4770     for (k = 0; k < (1 << (m - j)); k += 2) {
    4771       // [e01] [efrac] y(0) ... y(i-1) <k/2 s' values> <2^(m-j)-k s values>
    4772       writePSFmt("%d index %d get dup\n", i + k/2 + (1 << (m-j)) - k, j);
    4773       writePS("3 2 roll mul exch 1 exch sub 3 2 roll mul add\n");
    4774       writePSFmt("%d 1 roll\n", k/2 + (1 << m-j) - k - 1);
    4775     }
    4776     // [e01] [efrac] s'(0) s'(1) ... s(2^(m-j-1)-1)
     4769        // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^(m-j)-1)
     4770        for (k = 0; k < (1 << (m - j)); k += 2) {
     4771          // [e01] [efrac] y(0) ... y(i-1) <k/2 s' values> <2^(m-j)-k s values>
     4772          writePSFmt("%d index %d get dup\n", i + k/2 + (1 << (m-j)) - k, j);
     4773          writePS("3 2 roll mul exch 1 exch sub 3 2 roll mul add\n");
     4774          writePSFmt("%d 1 roll\n", k/2 + (1 << m-j) - k - 1);
     4775        }
     4776        // [e01] [efrac] s'(0) s'(1) ... s(2^(m-j-1)-1)
    47774777      }
    47784778      // [e01] [efrac] y(0) ... y(i-1) s
    47794779      writePSFmt("%g mul %g add\n",
    4780         func0->getDecodeMax(i) - func0->getDecodeMin(i),
    4781         func0->getDecodeMin(i));
     4780                func0->getDecodeMax(i) - func0->getDecodeMin(i),
     4781                func0->getDecodeMin(i));
    47824782      writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4783         func0->getRangeMin(i), func0->getRangeMin(i),
    4784         func0->getRangeMax(i), func0->getRangeMax(i));
     4783                func0->getRangeMin(i), func0->getRangeMin(i),
     4784                func0->getRangeMax(i), func0->getRangeMax(i));
    47854785      // [e01] [efrac] y(0) ... y(i-1) y(i)
    47864786    }
     
    47894789    break;
    47904790
    4791   case 2:           // exponential
     4791  case 2:                       // exponential
    47924792    func2 = (ExponentialFunction *)func;
    47934793    n = func2->getOutputSize();
    47944794    writePSFmt("{ dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4795            func2->getDomainMin(0), func2->getDomainMin(0),
    4796            func2->getDomainMax(0), func2->getDomainMax(0));
     4795               func2->getDomainMin(0), func2->getDomainMin(0),
     4796               func2->getDomainMax(0), func2->getDomainMax(0));
    47974797    // x
    47984798    for (i = 0; i < n; ++i) {
    47994799      // x y(0) .. y(i-1)
    48004800      writePSFmt("%d index %g exp %g mul %g add\n",
    4801         i, func2->getE(), func2->getC1()[i] - func2->getC0()[i],
    4802         func2->getC0()[i]);
     4801                i, func2->getE(), func2->getC1()[i] - func2->getC0()[i],
     4802                func2->getC0()[i]);
    48034803      if (func2->getHasRange()) {
    4804     writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4805            func2->getRangeMin(i), func2->getRangeMin(i),
    4806            func2->getRangeMax(i), func2->getRangeMax(i));
     4804        writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
     4805                   func2->getRangeMin(i), func2->getRangeMin(i),
     4806                   func2->getRangeMax(i), func2->getRangeMax(i));
    48074807      }
    48084808    }
     
    48114811    break;
    48124812
    4813   case 3:           // stitching
     4813  case 3:                       // stitching
    48144814    func3 = (StitchingFunction *)func;
    48154815    thisFunc = nextFunc++;
     
    48194819    }
    48204820    writePSFmt("{ dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4821            func3->getDomainMin(0), func3->getDomainMin(0),
    4822            func3->getDomainMax(0), func3->getDomainMax(0));
     4821               func3->getDomainMin(0), func3->getDomainMin(0),
     4822               func3->getDomainMax(0), func3->getDomainMax(0));
    48234823    for (i = 0; i < func3->getNumFuncs() - 1; ++i) {
    48244824      writePSFmt("dup %g lt { %g sub %g mul %g add xpdfFunc%d_%d } {\n",
    4825         func3->getBounds()[i+1],
    4826         func3->getBounds()[i],
    4827         (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
    4828            (func3->getBounds()[i+1] - func3->getBounds()[i]),
    4829         func3->getEncode()[2*i],
    4830         thisFunc, i);
     4825                func3->getBounds()[i+1],
     4826                func3->getBounds()[i],
     4827                (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
     4828                   (func3->getBounds()[i+1] - func3->getBounds()[i]),
     4829                func3->getEncode()[2*i],
     4830                thisFunc, i);
    48314831    }
    48324832    writePSFmt("%g sub %g mul %g add xpdfFunc%d_%d\n",
    4833            func3->getBounds()[i],
    4834            (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
    4835              (func3->getBounds()[i+1] - func3->getBounds()[i]),
    4836            func3->getEncode()[2*i],
    4837            thisFunc, i);
     4833               func3->getBounds()[i],
     4834               (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
     4835                 (func3->getBounds()[i+1] - func3->getBounds()[i]),
     4836               func3->getEncode()[2*i],
     4837               thisFunc, i);
    48384838    for (i = 0; i < func3->getNumFuncs() - 1; ++i) {
    48394839      writePS("} ifelse\n");
     
    48424842    break;
    48434843
    4844   case 4:           // PostScript
     4844  case 4:                       // PostScript
    48454845    func4 = (PostScriptFunction *)func;
    48464846    writePS(func4->getCodeString()->getCString());
     
    49164916  while ((c = *p++)) {
    49174917    if (c <= (char)0x20 || c >= (char)0x7f ||
    4918     c == '(' || c == ')' || c == '<' || c == '>' ||
    4919     c == '[' || c == ']' || c == '{' || c == '}' ||
    4920     c == '/' || c == '%') {
     4918        c == '(' || c == ')' || c == '<' || c == '>' ||
     4919        c == '[' || c == ']' || c == '{' || c == '}' ||
     4920        c == '/' || c == '%') {
    49214921      writePSFmt("#%02x", c & 0xff);
    49224922    } else {
     
    49454945    c = name->getChar(i);
    49464946    if (c <= (char)0x20 || c >= (char)0x7f ||
    4947     c == '(' || c == ')' || c == '<' || c == '>' ||
    4948     c == '[' || c == ']' || c == '{' || c == '}' ||
    4949     c == '/' || c == '%') {
     4947        c == '(' || c == ')' || c == '<' || c == '>' ||
     4948        c == '[' || c == ']' || c == '{' || c == '}' ||
     4949        c == '/' || c == '%') {
    49504950      sprintf(buf, "#%02x", c & 0xff);
    49514951      name2->append(buf);
  • trunk/poppler/mypoppler/poppler/PSOutputDev.h

    r2 r134  
    5252
    5353  // Open a PostScript output file, and write the prolog.
    54   PSOutputDev(char *fileName, XRef *xrefA, Catalog *catalog,
     54  PSOutputDev(const char *fileName, XRef *xrefA, Catalog *catalog,
    5555              int firstPage, int lastPage, PSOutMode modeA,
    5656              int paperWidthA = -1, int paperHeightA = -1,
  • trunk/poppler/mypoppler/poppler/Page.cc

    r50 r134  
    350350}
    351351
    352 
    353352void Page::displaySlice(OutputDev *out, double hDPI, double vDPI,
    354353                        int rotate, GBool useMediaBox, GBool crop,
  • trunk/poppler/mypoppler/poppler/Parser.cc

    r2 r134  
    4040                       Guchar *fileKey, int keyLength,
    4141                       int objNum, int objGen) {
    42   char *key;
    4342  Stream *str;
    4443  Object obj2;
     
    7776        shift();
    7877      } else {
    79         key = copyString(buf1.getName());
     78        // buf1 might go away in shift(), so construct the key
     79        UGooString *key = new UGooString(buf1.getName());
    8080        shift();
    8181        if (buf1.isEOF() || buf1.isError()) {
     
    8383          break;
    8484        }
    85         obj->dictAdd(key, getObj(&obj2, fileKey, keyLength, objNum, objGen));
    86         gfree(key);
     85        obj->dictAddOwnKeyVal(key, getObj(&obj2, fileKey, keyLength, objNum, objGen));
    8786      }
    8887    }
     
    131130  // simple object
    132131  } else {
    133     buf1.copy(obj);
     132    // avoid re-allocating memory for complex objects like strings by
     133    // shallow copy of <buf1> to <obj> and nulling <buf1> so that
     134    // subsequent buf1.free() won't free this memory
     135    buf1.shallowCopy(obj);
     136    buf1.initNull();
    134137    shift();
    135138  }
     
    209212  }
    210213  buf1.free();
    211   buf1 = buf2;
     214  buf2.shallowCopy(&buf1);
    212215  if (inlineImg > 0)            // don't buffer inline image data
    213216    buf2.initNull();
  • trunk/poppler/mypoppler/poppler/SplashOutputDev.cc

    r44 r134  
    228228    break;
    229229  case splashModeRGB8:
     230  case splashModeRGB8Qt:
    230231    cvtRGBToHSV(src[0], src[1], src[2], &hs, &ss, &vs);
    231232    cvtRGBToHSV(dest[0], dest[1], dest[2], &hd, &sd, &vd);
     
    274275    break;
    275276  case splashModeRGB8:
     277  case splashModeRGB8Qt:
    276278    cvtRGBToHSV(src[0], src[1], src[2], &hs, &ss, &vs);
    277279    cvtRGBToHSV(dest[0], dest[1], dest[2], &hd, &sd, &vd);
     
    319321    break;
    320322  case splashModeRGB8:
     323  case splashModeRGB8Qt:
    321324    cvtRGBToHSV(src[0], src[1], src[2], &hs, &ss, &vs);
    322325    cvtRGBToHSV(dest[0], dest[1], dest[2], &hd, &sd, &vd);
     
    365368    break;
    366369  case splashModeRGB8:
     370  case splashModeRGB8Qt:
    367371    cvtRGBToHSV(src[0], src[1], src[2], &hs, &ss, &vs);
    368372    cvtRGBToHSV(dest[0], dest[1], dest[2], &hd, &sd, &vd);
     
    944948  SplashOutFontFileID *id;
    945949  SplashFontFile *fontFile;
    946   SplashFontSrc *fontsrc;
     950  SplashFontSrc *fontsrc = NULL;
    947951  FoFiTrueType *ff;
    948952  Ref embRef;
     
    10191023      fontsrc->setFile(fileName, gFalse);
    10201024    else
    1021       fontsrc->setBuf(tmpBuf, tmpBufLen, gFalse);
     1025      fontsrc->setBuf(tmpBuf, tmpBufLen, gTrue);
    10221026
    10231027    // load the font file
     
    11671171  font = fontEngine->getFont(fontFile, mat);
    11681172
     1173  if (fontsrc && !fontsrc->isFile)
     1174      fontsrc->unref();
    11691175  return;
    11701176
     
    11721178  delete id;
    11731179 err1:
     1180  if (fontsrc && !fontsrc->isFile)
     1181      fontsrc->unref();
    11741182  return;
    11751183}
     
    19361944      break;
    19371945    case splashModeRGB8:
     1946    case splashModeRGB8Qt:
    19381947      imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
    19391948      for (i = 0; i < n; ++i) {
     
    19801989    break;
    19811990  case splashModeRGB8:
     1991  case splashModeRGB8Qt:
    19821992    srcMode = maskColors ? splashModeARGB8 : splashModeRGB8;
    19831993    break;
     
    22162226      break;
    22172227    case splashModeRGB8:
     2228    case splashModeRGB8Qt:
    22182229      imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
    22192230      for (i = 0; i < n; ++i) {
     
    22602271    break;
    22612272  case splashModeRGB8:
     2273  case splashModeRGB8Qt:
    22622274    srcMode = splashModeARGB8;
    22632275    break;
     
    23742386      break;
    23752387    case splashModeRGB8:
     2388    case splashModeRGB8Qt:
    23762389      imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
    23772390      for (i = 0; i < n; ++i) {
     
    24182431    break;
    24192432  case splashModeRGB8:
     2433  case splashModeRGB8Qt:
    24202434    srcMode = splashModeRGB8;
    24212435    break;
  • trunk/poppler/mypoppler/poppler/Stream.cc

    r2 r134  
    422422  ok = gFalse;
    423423
     424  nVals = width * nComps;
    424425  if (width <= 0 || nComps <= 0 || nBits <= 0 ||
    425426      nComps >= INT_MAX/nBits ||
     
    428429    return;
    429430  }
    430   nVals = width * nComps;
    431431  totalBits = nVals * nBits;
    432432  if (totalBits == 0 ||
  • trunk/poppler/mypoppler/poppler/TextOutputDev.cc

    r27 r134  
    119119TextFontInfo::TextFontInfo(GfxState *state) {
    120120  gfxFont = state->getFont();
     121  if (gfxFont)
     122    gfxFont->incRefCnt();
    121123#if TEXTOUT_WORD_LIST
    122124  fontName = (gfxFont && gfxFont->getOrigName())
     
    127129
    128130TextFontInfo::~TextFontInfo() {
     131  if (gfxFont)
     132    gfxFont->decRefCnt();
    129133#if TEXTOUT_WORD_LIST
    130134  if (fontName) {
     
    33143318
    33153319  out->startPage (0, state);
     3320  out->setDefaultCTM (state->getCTM());
    33163321
    33173322  state->setTextMat(1, 0, 0, -1, 0, 0);
  • trunk/poppler/mypoppler/poppler/UGooString.cc

    r2 r134  
    5252  length = str.getLength();
    5353  s = (Unicode *)gmallocn(length, sizeof(Unicode));
    54   for (int j = 0; j < length; ++j) {
     54  bool anyNonEncoded = false;
     55  for (int j = 0; j < length && !anyNonEncoded; ++j) {
    5556    s[j] = pdfDocEncoding[str.getChar(j) & 0xff];
     57    if (!s[j]) anyNonEncoded = true;
     58  }
     59  if ( anyNonEncoded )
     60  {
     61    for (int j = 0; j < length; ++j) {
     62      s[j] = str.getChar(j);
     63    }
    5664  }
    5765}
  • trunk/poppler/mypoppler/splash/Splash.cc

    r44 r134  
    31163116            case splashModeRGB8:
    31173117            case splashModeBGR8:
     3118            case splashModeRGB8Qt:
    31183119              pix[2] = (int)((SplashCoord)pixAcc2 * pixMul);
    31193120              pix[1] = (int)((SplashCoord)pixAcc1 * pixMul);
     
    32503251        case splashModeRGB8:
    32513252        case splashModeBGR8:
     3253        case splashModeRGB8Qt:
    32523254          p = pixBuf + xSrc * 3;
    32533255          pixAcc0 = pixAcc1 = pixAcc2 = 0;
     
    32953297#endif
    32963298          case splashModeRGB8:
     3299          case splashModeRGB8Qt:
    32973300          case splashModeBGR8:
    32983301            pix[2] = (int)((SplashCoord)pixAcc2 * pixMul);
  • trunk/poppler/mypoppler/splash/SplashFontEngine.cc

    r2 r134  
    127127  // return an error, leaving the file to be deleted later (if
    128128  // loadXYZFont failed, the file will always be deleted)
    129   src->unref();
     129  if (src->isFile)
     130    src->unref();
    130131#endif
    131132
     
    155156  // return an error, leaving the file to be deleted later (if
    156157  // loadXYZFont failed, the file will always be deleted)
    157   src->unref();
     158  if (src->isFile)
     159    src->unref();
    158160#endif
    159161
     
    177179  // return an error, leaving the file to be deleted later (if
    178180  // loadXYZFont failed, the file will always be deleted)
    179   src->unref();
     181  if (src->isFile)
     182    src->unref();
    180183#endif
    181184
     
    207210  // return an error, leaving the file to be deleted later (if
    208211  // loadXYZFont failed, the file will always be deleted)
    209   src->unref();
     212  if (src->isFile)
     213    src->unref();
    210214#endif
    211215
Note: See TracChangeset for help on using the changeset viewer.