Ignore:
Timestamp:
Dec 30, 2009, 7:13:45 PM (12 years ago)
Author:
rbri
Message:

PDF plugin: Poppler library updated to version 0.12.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/Function.cc

    r257 r277  
    1414// under GPL version 2 or later
    1515//
    16 // Copyright (C) 2006, 2008 Albert Astals Cid <aacid@kde.org>
     16// Copyright (C) 2006, 2008, 2009 Albert Astals Cid <aacid@kde.org>
    1717// Copyright (C) 2006 Jeff Muizelaar <jeff@infidigm.net>
    1818//
     
    3333#include <math.h>
    3434#include "goo/gmem.h"
     35#include "goo/gstrtod.h"
    3536#include "Object.h"
    3637#include "Dict.h"
     
    3839#include "Error.h"
    3940#include "Function.h"
     41#include "PopplerCache.h"
    4042
    4143#ifndef M_PI
     
    862864public:
    863865
    864   PSStack() { sp = psStackSize; }
    865   void pushBool(GBool booln);
    866   void pushInt(int intg);
    867   void pushReal(double real);
    868   GBool popBool();
    869   int popInt();
    870   double popNum();
     866  PSStack() {sp = psStackSize; }
     867  void clear() { sp = psStackSize; }
     868  void pushBool(GBool booln)
     869  {
     870    if (checkOverflow()) {
     871      stack[--sp].type = psBool;
     872      stack[sp].booln = booln;
     873    }
     874  }
     875  void pushInt(int intg)
     876  {
     877    if (checkOverflow()) {
     878      stack[--sp].type = psInt;
     879      stack[sp].intg = intg;
     880    }
     881  }
     882  void pushReal(double real)
     883  {
     884    if (checkOverflow()) {
     885      stack[--sp].type = psReal;
     886      stack[sp].real = real;
     887    }
     888  }
     889  GBool popBool()
     890  {
     891    if (checkUnderflow() && checkType(psBool, psBool)) {
     892      return stack[sp++].booln;
     893    }
     894    return gFalse;
     895  }
     896  int popInt()
     897  {
     898    if (checkUnderflow() && checkType(psInt, psInt)) {
     899      return stack[sp++].intg;
     900    }
     901    return 0;
     902  }
     903  double popNum()
     904  {
     905    double ret;
     906
     907    if (checkUnderflow() && checkType(psInt, psReal)) {
     908      ret = (stack[sp].type == psInt) ? (double)stack[sp].intg : stack[sp].real;
     909      ++sp;
     910      return ret;
     911    }
     912    return 0;
     913  }
    871914  GBool empty() { return sp == psStackSize; }
    872915  GBool topIsInt() { return sp < psStackSize && stack[sp].type == psInt; }
     
    882925  void copy(int n);
    883926  void roll(int n, int j);
    884   void index(int i);
    885   void pop();
     927  void index(int i)
     928  {
     929    if (!checkOverflow()) {
     930      return;
     931    }
     932    --sp;
     933    stack[sp] = stack[sp + 1 + i];
     934  }
     935  void pop()
     936  {
     937    if (!checkUnderflow()) {
     938      return;
     939    }
     940    ++sp;
     941  }
    886942
    887943private:
    888944
    889   GBool checkOverflow(int n = 1);
    890   GBool checkUnderflow();
    891   GBool checkType(PSObjectType t1, PSObjectType t2);
    892 
     945  GBool checkOverflow(int n = 1)
     946  {
     947    if (sp - n < 0) {
     948      error(-1, "Stack overflow in PostScript function");
     949      return gFalse;
     950    }
     951    return gTrue;
     952  }
     953  GBool checkUnderflow()
     954  {
     955    if (sp == psStackSize) {
     956      error(-1, "Stack underflow in PostScript function");
     957      return gFalse;
     958    }
     959    return gTrue;
     960  }
     961  GBool checkType(PSObjectType t1, PSObjectType t2)
     962  {
     963    if (stack[sp].type != t1 && stack[sp].type != t2) {
     964      error(-1, "Type mismatch in PostScript function");
     965      return gFalse;
     966    }
     967    return gTrue;
     968  }
    893969  PSObject stack[psStackSize];
    894970  int sp;
    895971};
    896972
    897 GBool PSStack::checkOverflow(int n) {
    898   if (sp - n < 0) {
    899     error(-1, "Stack overflow in PostScript function");
    900     return gFalse;
    901   }
    902   return gTrue;
    903 }
    904 
    905 GBool PSStack::checkUnderflow() {
    906   if (sp == psStackSize) {
    907     error(-1, "Stack underflow in PostScript function");
    908     return gFalse;
    909   }
    910   return gTrue;
    911 }
    912 
    913 GBool PSStack::checkType(PSObjectType t1, PSObjectType t2) {
    914   if (stack[sp].type != t1 && stack[sp].type != t2) {
    915     error(-1, "Type mismatch in PostScript function");
    916     return gFalse;
    917   }
    918   return gTrue;
    919 }
    920 
    921 void PSStack::pushBool(GBool booln) {
    922   if (checkOverflow()) {
    923     stack[--sp].type = psBool;
    924     stack[sp].booln = booln;
    925   }
    926 }
    927 
    928 void PSStack::pushInt(int intg) {
    929   if (checkOverflow()) {
    930     stack[--sp].type = psInt;
    931     stack[sp].intg = intg;
    932   }
    933 }
    934 
    935 void PSStack::pushReal(double real) {
    936   if (checkOverflow()) {
    937     stack[--sp].type = psReal;
    938     stack[sp].real = real;
    939   }
    940 }
    941 
    942 GBool PSStack::popBool() {
    943   if (checkUnderflow() && checkType(psBool, psBool)) {
    944     return stack[sp++].booln;
    945   }
    946   return gFalse;
    947 }
    948 
    949 int PSStack::popInt() {
    950   if (checkUnderflow() && checkType(psInt, psInt)) {
    951     return stack[sp++].intg;
    952   }
    953   return 0;
    954 }
    955 
    956 double PSStack::popNum() {
    957   double ret;
    958 
    959   if (checkUnderflow() && checkType(psInt, psReal)) {
    960     ret = (stack[sp].type == psInt) ? (double)stack[sp].intg : stack[sp].real;
    961     ++sp;
    962     return ret;
    963   }
    964   return 0;
    965 }
    966973
    967974void PSStack::copy(int n) {
     
    9961003    return;
    9971004  }
    998   for (i = 0; i < j; ++i) {
    999     obj = stack[sp];
    1000     for (k = sp; k < sp + n - 1; ++k) {
    1001       stack[k] = stack[k+1];
    1002     }
    1003     stack[sp + n - 1] = obj;
    1004   }
    1005 }
    1006 
    1007 void PSStack::index(int i) {
    1008   if (!checkOverflow()) {
    1009     return;
    1010   }
    1011   --sp;
    1012   stack[sp] = stack[sp + 1 + i];
    1013 }
    1014 
    1015 void PSStack::pop() {
    1016   if (!checkUnderflow()) {
    1017     return;
    1018   }
    1019   ++sp;
    1020 }
     1005  if (j <= n / 2) {
     1006    for (i = 0; i < j; ++i) {
     1007      obj = stack[sp];
     1008      for (k = sp; k < sp + n - 1; ++k) {
     1009        stack[k] = stack[k+1];
     1010      }
     1011      stack[sp + n - 1] = obj;
     1012    }
     1013  } else {
     1014    j = n - j;
     1015    obj = stack[sp + n - 1];
     1016    for (k = sp + n - 1; k > sp; --k) {
     1017      stack[k] = stack[k-1];
     1018    }
     1019    stack[sp] = obj;
     1020  }
     1021}
     1022
     1023class PostScriptFunctionKey : public PopplerCacheKey
     1024{
     1025  public:
     1026    PostScriptFunctionKey(int sizeA, double *inA, bool copyA)
     1027    {
     1028      init(sizeA, inA, copyA);
     1029    }
     1030   
     1031    PostScriptFunctionKey(const PostScriptFunctionKey &key)
     1032    {
     1033      init(key.size, key.in, key.copied);
     1034    }
     1035   
     1036    void init(int sizeA, double *inA, bool copyA)
     1037    {
     1038      copied = copyA;
     1039      size = sizeA;
     1040      if (copied) {
     1041        in = new double[size];
     1042        for (int i = 0; i < size; ++i) in[i] = inA[i];
     1043      } else {
     1044        in = inA;
     1045      }
     1046    }
     1047   
     1048    ~PostScriptFunctionKey()
     1049    {
     1050      if (copied) delete[] in;
     1051    }
     1052       
     1053    bool operator==(const PopplerCacheKey &key) const
     1054    {
     1055      const PostScriptFunctionKey *k = static_cast<const PostScriptFunctionKey*>(&key);
     1056      if (size == k->size) {
     1057        bool equal = true;
     1058        for (int i = 0; equal && i < size; ++i) {
     1059          equal = in[i] == k->in[i];
     1060        }
     1061        return equal;
     1062      } else {
     1063        return false;
     1064      }
     1065    }
     1066 
     1067    bool copied;
     1068    int size;
     1069    double *in;
     1070};
     1071
     1072class PostScriptFunctionItem : public PopplerCacheItem
     1073{
     1074  public:
     1075    PostScriptFunctionItem(int sizeA, double *outA)
     1076    {
     1077      init(sizeA, outA);
     1078    }
     1079   
     1080    PostScriptFunctionItem(const PostScriptFunctionItem &item)
     1081    {
     1082      init(item.size, item.out);
     1083    }
     1084   
     1085    void init(int sizeA, double *outA)
     1086    {
     1087      size = sizeA;
     1088      out = new double[size];
     1089      for (int i = 0; i < size; ++i) out[i] = outA[i];
     1090    }
     1091   
     1092    ~PostScriptFunctionItem()
     1093    {
     1094      delete[] out;
     1095    }
     1096   
     1097    int size;
     1098    double *out;
     1099};
    10211100
    10221101PostScriptFunction::PostScriptFunction(Object *funcObj, Dict *dict) {
     
    10291108  codeSize = 0;
    10301109  ok = gFalse;
     1110  cache = new PopplerCache(5);
    10311111
    10321112  //----- initialize the generic stuff
     
    10641144
    10651145  ok = gTrue;
     1146 
     1147  stack = new PSStack();
    10661148
    10671149 err2:
     
    10761158  memcpy(code, func->code, codeSize * sizeof(PSObject));
    10771159  codeString = func->codeString->copy();
     1160  stack = new PSStack();
     1161  memcpy(stack, func->stack, sizeof(PSStack));
     1162 
     1163  cache = new PopplerCache(func->cache->size());
     1164  for (int i = 0; i < func->cache->numberOfItems(); ++i)
     1165  {
     1166    PostScriptFunctionKey *key = new PostScriptFunctionKey(*(PostScriptFunctionKey*)func->cache->key(i));
     1167    PostScriptFunctionItem *item = new PostScriptFunctionItem(*(PostScriptFunctionItem*)func->cache->item(i));
     1168    cache->put(key, item);
     1169  }
    10781170}
    10791171
     
    10811173  gfree(code);
    10821174  delete codeString;
     1175  delete stack;
     1176  delete cache;
    10831177}
    10841178
    10851179void PostScriptFunction::transform(double *in, double *out) {
    1086   PSStack *stack;
    10871180  int i;
    1088 
    1089   stack = new PSStack();
     1181 
     1182  PostScriptFunctionKey key(m, in, false);
     1183  PopplerCacheItem *item = cache->lookup(key);
     1184  if (item) {
     1185    PostScriptFunctionItem *it = static_cast<PostScriptFunctionItem *>(item);
     1186    for (int i = 0; i < n; ++i) {
     1187      out[i] = it->out[i];
     1188    }
     1189    return;
     1190  }
     1191
     1192  stack->clear();
    10901193  for (i = 0; i < m; ++i) {
    10911194    //~ may need to check for integers here
     
    11011204    }
    11021205  }
     1206
     1207  PostScriptFunctionKey *newKey = new PostScriptFunctionKey(m, in, true);
     1208  PostScriptFunctionItem *newItem = new PostScriptFunctionItem(n, out);
     1209  cache->put(newKey, newItem);
     1210 
    11031211  // if (!stack->empty()) {
    11041212  //   error(-1, "Extra values on stack at end of PostScript function");
    11051213  // }
    1106   delete stack;
    11071214}
    11081215
     
    11311238      if (isReal) {
    11321239        code[*codePtr].type = psReal;
    1133           code[*codePtr].real = atof(tok->getCString());
     1240          code[*codePtr].real = gatof(tok->getCString());
    11341241      } else {
    11351242        code[*codePtr].type = psInt;
Note: See TracChangeset for help on using the changeset viewer.