summaryrefslogtreecommitdiff
path: root/core/fpdfapi/page/cpdf_psengine.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'core/fpdfapi/page/cpdf_psengine.cpp')
-rw-r--r--core/fpdfapi/page/cpdf_psengine.cpp405
1 files changed, 405 insertions, 0 deletions
diff --git a/core/fpdfapi/page/cpdf_psengine.cpp b/core/fpdfapi/page/cpdf_psengine.cpp
new file mode 100644
index 0000000000..658d73cda3
--- /dev/null
+++ b/core/fpdfapi/page/cpdf_psengine.cpp
@@ -0,0 +1,405 @@
+// Copyright 2017 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "core/fpdfapi/page/cpdf_psengine.h"
+
+#include <utility>
+
+#include "core/fpdfapi/parser/cpdf_simple_parser.h"
+#include "core/fxcrt/fx_safe_types.h"
+#include "core/fxcrt/fx_string.h"
+#include "third_party/base/logging.h"
+#include "third_party/base/ptr_util.h"
+
+namespace {
+
+struct PDF_PSOpName {
+ const char* name;
+ PDF_PSOP op;
+};
+
+const PDF_PSOpName kPsOpNames[] = {
+ {"add", PSOP_ADD}, {"sub", PSOP_SUB},
+ {"mul", PSOP_MUL}, {"div", PSOP_DIV},
+ {"idiv", PSOP_IDIV}, {"mod", PSOP_MOD},
+ {"neg", PSOP_NEG}, {"abs", PSOP_ABS},
+ {"ceiling", PSOP_CEILING}, {"floor", PSOP_FLOOR},
+ {"round", PSOP_ROUND}, {"truncate", PSOP_TRUNCATE},
+ {"sqrt", PSOP_SQRT}, {"sin", PSOP_SIN},
+ {"cos", PSOP_COS}, {"atan", PSOP_ATAN},
+ {"exp", PSOP_EXP}, {"ln", PSOP_LN},
+ {"log", PSOP_LOG}, {"cvi", PSOP_CVI},
+ {"cvr", PSOP_CVR}, {"eq", PSOP_EQ},
+ {"ne", PSOP_NE}, {"gt", PSOP_GT},
+ {"ge", PSOP_GE}, {"lt", PSOP_LT},
+ {"le", PSOP_LE}, {"and", PSOP_AND},
+ {"or", PSOP_OR}, {"xor", PSOP_XOR},
+ {"not", PSOP_NOT}, {"bitshift", PSOP_BITSHIFT},
+ {"true", PSOP_TRUE}, {"false", PSOP_FALSE},
+ {"if", PSOP_IF}, {"ifelse", PSOP_IFELSE},
+ {"pop", PSOP_POP}, {"exch", PSOP_EXCH},
+ {"dup", PSOP_DUP}, {"copy", PSOP_COPY},
+ {"index", PSOP_INDEX}, {"roll", PSOP_ROLL}};
+
+} // namespace
+
+class CPDF_PSOP {
+ public:
+ explicit CPDF_PSOP(PDF_PSOP op) : m_op(op), m_value(0) {
+ ASSERT(m_op != PSOP_CONST);
+ ASSERT(m_op != PSOP_PROC);
+ }
+ explicit CPDF_PSOP(float value) : m_op(PSOP_CONST), m_value(value) {}
+ CPDF_PSOP()
+ : m_op(PSOP_PROC),
+ m_value(0),
+ m_proc(pdfium::MakeUnique<CPDF_PSProc>()) {}
+
+ float GetFloatValue() const {
+ if (m_op == PSOP_CONST)
+ return m_value;
+
+ NOTREACHED();
+ return 0;
+ }
+ CPDF_PSProc* GetProc() const {
+ if (m_op == PSOP_PROC)
+ return m_proc.get();
+ NOTREACHED();
+ return nullptr;
+ }
+
+ PDF_PSOP GetOp() const { return m_op; }
+
+ private:
+ const PDF_PSOP m_op;
+ const float m_value;
+ std::unique_ptr<CPDF_PSProc> m_proc;
+};
+
+bool CPDF_PSEngine::Execute() {
+ return m_MainProc.Execute(this);
+}
+
+CPDF_PSProc::CPDF_PSProc() {}
+CPDF_PSProc::~CPDF_PSProc() {}
+
+bool CPDF_PSProc::Execute(CPDF_PSEngine* pEngine) {
+ for (size_t i = 0; i < m_Operators.size(); ++i) {
+ const PDF_PSOP op = m_Operators[i]->GetOp();
+ if (op == PSOP_PROC)
+ continue;
+
+ if (op == PSOP_CONST) {
+ pEngine->Push(m_Operators[i]->GetFloatValue());
+ continue;
+ }
+
+ if (op == PSOP_IF) {
+ if (i == 0 || m_Operators[i - 1]->GetOp() != PSOP_PROC)
+ return false;
+
+ if (static_cast<int>(pEngine->Pop()))
+ m_Operators[i - 1]->GetProc()->Execute(pEngine);
+ } else if (op == PSOP_IFELSE) {
+ if (i < 2 || m_Operators[i - 1]->GetOp() != PSOP_PROC ||
+ m_Operators[i - 2]->GetOp() != PSOP_PROC) {
+ return false;
+ }
+ size_t offset = static_cast<int>(pEngine->Pop()) ? 2 : 1;
+ m_Operators[i - offset]->GetProc()->Execute(pEngine);
+ } else {
+ pEngine->DoOperator(op);
+ }
+ }
+ return true;
+}
+
+CPDF_PSEngine::CPDF_PSEngine() : m_StackCount(0) {}
+
+CPDF_PSEngine::~CPDF_PSEngine() {}
+
+void CPDF_PSEngine::Push(float v) {
+ if (m_StackCount < PSENGINE_STACKSIZE)
+ m_Stack[m_StackCount++] = v;
+}
+
+float CPDF_PSEngine::Pop() {
+ return m_StackCount > 0 ? m_Stack[--m_StackCount] : 0;
+}
+
+bool CPDF_PSEngine::Parse(const char* str, int size) {
+ CPDF_SimpleParser parser(reinterpret_cast<const uint8_t*>(str), size);
+ CFX_ByteStringC word = parser.GetWord();
+ return word == "{" ? m_MainProc.Parse(&parser, 0) : false;
+}
+
+bool CPDF_PSProc::Parse(CPDF_SimpleParser* parser, int depth) {
+ if (depth > kMaxDepth)
+ return false;
+
+ while (1) {
+ CFX_ByteStringC word = parser->GetWord();
+ if (word.IsEmpty())
+ return false;
+
+ if (word == "}")
+ return true;
+
+ if (word == "{") {
+ m_Operators.push_back(pdfium::MakeUnique<CPDF_PSOP>());
+ if (!m_Operators.back()->GetProc()->Parse(parser, depth + 1))
+ return false;
+ continue;
+ }
+
+ std::unique_ptr<CPDF_PSOP> op;
+ for (const PDF_PSOpName& op_name : kPsOpNames) {
+ if (word == CFX_ByteStringC(op_name.name)) {
+ op = pdfium::MakeUnique<CPDF_PSOP>(op_name.op);
+ break;
+ }
+ }
+ if (!op)
+ op = pdfium::MakeUnique<CPDF_PSOP>(FX_atof(word));
+ m_Operators.push_back(std::move(op));
+ }
+}
+
+bool CPDF_PSEngine::DoOperator(PDF_PSOP op) {
+ int i1;
+ int i2;
+ float d1;
+ float d2;
+ FX_SAFE_INT32 result;
+ switch (op) {
+ case PSOP_ADD:
+ d1 = Pop();
+ d2 = Pop();
+ Push(d1 + d2);
+ break;
+ case PSOP_SUB:
+ d2 = Pop();
+ d1 = Pop();
+ Push(d1 - d2);
+ break;
+ case PSOP_MUL:
+ d1 = Pop();
+ d2 = Pop();
+ Push(d1 * d2);
+ break;
+ case PSOP_DIV:
+ d2 = Pop();
+ d1 = Pop();
+ Push(d1 / d2);
+ break;
+ case PSOP_IDIV:
+ i2 = static_cast<int>(Pop());
+ i1 = static_cast<int>(Pop());
+ if (i2) {
+ result = i1;
+ result /= i2;
+ Push(result.ValueOrDefault(0));
+ } else {
+ Push(0);
+ }
+ break;
+ case PSOP_MOD:
+ i2 = static_cast<int>(Pop());
+ i1 = static_cast<int>(Pop());
+ if (i2) {
+ result = i1;
+ result %= i2;
+ Push(result.ValueOrDefault(0));
+ } else {
+ Push(0);
+ }
+ break;
+ case PSOP_NEG:
+ d1 = Pop();
+ Push(-d1);
+ break;
+ case PSOP_ABS:
+ d1 = Pop();
+ Push((float)fabs(d1));
+ break;
+ case PSOP_CEILING:
+ d1 = Pop();
+ Push((float)ceil(d1));
+ break;
+ case PSOP_FLOOR:
+ d1 = Pop();
+ Push((float)floor(d1));
+ break;
+ case PSOP_ROUND:
+ d1 = Pop();
+ Push(FXSYS_round(d1));
+ break;
+ case PSOP_TRUNCATE:
+ i1 = (int)Pop();
+ Push(i1);
+ break;
+ case PSOP_SQRT:
+ d1 = Pop();
+ Push((float)sqrt(d1));
+ break;
+ case PSOP_SIN:
+ d1 = Pop();
+ Push((float)sin(d1 * FX_PI / 180.0f));
+ break;
+ case PSOP_COS:
+ d1 = Pop();
+ Push((float)cos(d1 * FX_PI / 180.0f));
+ break;
+ case PSOP_ATAN:
+ d2 = Pop();
+ d1 = Pop();
+ d1 = (float)(atan2(d1, d2) * 180.0 / FX_PI);
+ if (d1 < 0) {
+ d1 += 360;
+ }
+ Push(d1);
+ break;
+ case PSOP_EXP:
+ d2 = Pop();
+ d1 = Pop();
+ Push((float)FXSYS_pow(d1, d2));
+ break;
+ case PSOP_LN:
+ d1 = Pop();
+ Push((float)log(d1));
+ break;
+ case PSOP_LOG:
+ d1 = Pop();
+ Push((float)log10(d1));
+ break;
+ case PSOP_CVI:
+ i1 = (int)Pop();
+ Push(i1);
+ break;
+ case PSOP_CVR:
+ break;
+ case PSOP_EQ:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 == d2));
+ break;
+ case PSOP_NE:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 != d2));
+ break;
+ case PSOP_GT:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 > d2));
+ break;
+ case PSOP_GE:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 >= d2));
+ break;
+ case PSOP_LT:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 < d2));
+ break;
+ case PSOP_LE:
+ d2 = Pop();
+ d1 = Pop();
+ Push((int)(d1 <= d2));
+ break;
+ case PSOP_AND:
+ i1 = (int)Pop();
+ i2 = (int)Pop();
+ Push(i1 & i2);
+ break;
+ case PSOP_OR:
+ i1 = (int)Pop();
+ i2 = (int)Pop();
+ Push(i1 | i2);
+ break;
+ case PSOP_XOR:
+ i1 = (int)Pop();
+ i2 = (int)Pop();
+ Push(i1 ^ i2);
+ break;
+ case PSOP_NOT:
+ i1 = (int)Pop();
+ Push((int)!i1);
+ break;
+ case PSOP_BITSHIFT: {
+ int shift = (int)Pop();
+ result = (int)Pop();
+ if (shift > 0) {
+ result <<= shift;
+ } else {
+ // Avoids unsafe negation of INT_MIN.
+ FX_SAFE_INT32 safe_shift = shift;
+ result >>= (-safe_shift).ValueOrDefault(0);
+ }
+ Push(result.ValueOrDefault(0));
+ break;
+ }
+ case PSOP_TRUE:
+ Push(1);
+ break;
+ case PSOP_FALSE:
+ Push(0);
+ break;
+ case PSOP_POP:
+ Pop();
+ break;
+ case PSOP_EXCH:
+ d2 = Pop();
+ d1 = Pop();
+ Push(d2);
+ Push(d1);
+ break;
+ case PSOP_DUP:
+ d1 = Pop();
+ Push(d1);
+ Push(d1);
+ break;
+ case PSOP_COPY: {
+ int n = static_cast<int>(Pop());
+ if (n < 0 || m_StackCount + n > PSENGINE_STACKSIZE ||
+ n > static_cast<int>(m_StackCount))
+ break;
+ for (int i = 0; i < n; i++)
+ m_Stack[m_StackCount + i] = m_Stack[m_StackCount + i - n];
+ m_StackCount += n;
+ break;
+ }
+ case PSOP_INDEX: {
+ int n = static_cast<int>(Pop());
+ if (n < 0 || n >= static_cast<int>(m_StackCount))
+ break;
+ Push(m_Stack[m_StackCount - n - 1]);
+ break;
+ }
+ case PSOP_ROLL: {
+ int j = static_cast<int>(Pop());
+ int n = static_cast<int>(Pop());
+ if (j == 0 || n == 0 || m_StackCount == 0)
+ break;
+ if (n < 0 || n > static_cast<int>(m_StackCount))
+ break;
+
+ j %= n;
+ if (j > 0)
+ j -= n;
+ auto* begin_it = std::begin(m_Stack) + m_StackCount - n;
+ auto* middle_it = begin_it - j;
+ auto* end_it = std::begin(m_Stack) + m_StackCount;
+ std::rotate(begin_it, middle_it, end_it);
+ break;
+ }
+ default:
+ break;
+ }
+ return true;
+}