Remove typdefs for pointer types in fx_system.h

core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp

 // Copyright 2014 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 <limits.h>
 
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
@@ skipping 46 matching lines @@
     }
 private:
     FX_FLOAT    m_Stack[PSENGINE_STACKSIZE];
     int         m_StackCount;
     CPDF_PSProc m_MainProc;
 };
 CPDF_PSProc::~CPDF_PSProc()
 {
     int size = m_Operators.GetSize();
     for (int i = 0; i < size; i ++) {
-        if (m_Operators[i] == (FX_LPVOID)PSOP_PROC) {
+        if (m_Operators[i] == (void*)PSOP_PROC) {
             delete (CPDF_PSProc*)m_Operators[i + 1];
             i ++;
-        } else if (m_Operators[i] == (FX_LPVOID)PSOP_CONST) {
+        } else if (m_Operators[i] == (void*)PSOP_CONST) {
             FX_Free((FX_FLOAT*)m_Operators[i + 1]);
             i ++;
         }
     }
 }
 FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
 {
     int size = m_Operators.GetSize();
     for (int i = 0; i < size; i ++) {
         PDF_PSOP op = (PDF_PSOP)(uintptr_t)m_Operators[i];
         if (op == PSOP_PROC) {
             i ++;
         } else if (op == PSOP_CONST) {
             pEngine->Push(*(FX_FLOAT*)m_Operators[i + 1]);
             i ++;
         } else if (op == PSOP_IF) {
-            if (i < 2 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC) {
+            if (i < 2 || m_Operators[i - 2] != (void*)PSOP_PROC) {
                 return FALSE;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
             }
         } else if (op == PSOP_IFELSE) {
-            if (i < 4 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC ||
-                    m_Operators[i - 4] != (FX_LPVOID)PSOP_PROC) {
+            if (i < 4 || m_Operators[i - 2] != (void*)PSOP_PROC ||
+                    m_Operators[i - 4] != (void*)PSOP_PROC) {
                 return FALSE;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);
             } else {
                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
             }
         } else {
             pEngine->DoOperator(op);
         }
@@ skipping 34 matching lines @@
     {"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},
     {NULL, PSOP_PROC}
 };
 FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
 {
-    CPDF_SimpleParser parser((FX_LPBYTE)string, size);
+    CPDF_SimpleParser parser((uint8_t*)string, size);
     CFX_ByteStringC word = parser.GetWord();
     if (word != FX_BSTRC("{")) {
         return FALSE;
     }
     return m_MainProc.Parse(parser);
 }
 FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
 {
     while (1) {
         CFX_ByteStringC word = parser.GetWord();
         if (word.IsEmpty()) {
             return FALSE;
         }
         if (word == FX_BSTRC("}")) {
             return TRUE;
         }
         if (word == FX_BSTRC("{")) {
             CPDF_PSProc* pProc = new CPDF_PSProc;
-            m_Operators.Add((FX_LPVOID)PSOP_PROC);
+            m_Operators.Add((void*)PSOP_PROC);
             m_Operators.Add(pProc);
             if (!pProc->Parse(parser)) {
                 return FALSE;
             }
         } else {
             int i = 0;
             while (_PDF_PSOpNames[i].name) {
                 if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {
-                    m_Operators.Add((FX_LPVOID)_PDF_PSOpNames[i].op);
+                    m_Operators.Add((void*)_PDF_PSOpNames[i].op);
                     break;
                 }
                 i ++;
             }
             if (_PDF_PSOpNames[i].name == NULL) {
                 FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);
                 *pd = FX_atof(word);
-                m_Operators.Add((FX_LPVOID)PSOP_CONST);
+                m_Operators.Add((void*)PSOP_CONST);
                 m_Operators.Add(pd);
             }
         }
     }
 }
 #define PI 3.1415926535897932384626433832795f
 FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
 {
     int i1, i2;
     FX_FLOAT d1, d2;
@@ skipping 220 matching lines @@
             }
         default:
             break;
     }
     return TRUE;
 }
 static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)
 {
     return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
 }
-static FX_DWORD _GetBits32(FX_LPCBYTE pData, int bitpos, int nbits)
+static FX_DWORD _GetBits32(const uint8_t* pData, int bitpos, int nbits)
 {
     int result = 0;
     for (int i = 0; i < nbits; i ++)
         if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8))) {
             result |= 1 << (nbits - i - 1);
         }
     return result;
 }
 typedef struct {
     FX_FLOAT    encode_max, encode_min;
@@ skipping 116 matching lines @@
             index[i] = m_pEncodeInfo[i].sizes - 1;
         }
         pos += index[i] * blocksize[i];
     }
     FX_SAFE_INT32 bitpos = pos;
     bitpos *= m_nBitsPerSample;
     bitpos *= m_nOutputs;
     if (!bitpos.IsValid()) {
         return FALSE;
     }
-    FX_LPCBYTE pSampleData = m_pSampleStream->GetData();
+    const uint8_t* pSampleData = m_pSampleStream->GetData();
     if (pSampleData == NULL) {
         return FALSE;
     }
     FX_SAFE_INT32 bitpos1 = m_nOutputs - 1 > 0 ? m_nOutputs - 1 : 0; 
     bitpos1 *= m_nBitsPerSample;
     bitpos1 += bitpos.ValueOrDie();
     if (!bitpos1.IsValid()) {
         return FALSE;
     }
     for (int j = 0; j < m_nOutputs; j ++) {
@@ skipping 321 matching lines @@
         for (int i = 0; i < m_nOutputs; i ++) {
             if (results[i] < m_pRanges[i * 2]) {
                 results[i] = m_pRanges[i * 2];
             } else if (results[i] > m_pRanges[i * 2 + 1]) {
                 results[i] = m_pRanges[i * 2 + 1];
             }
         }
     }
     return TRUE;
 }