Use stdint.h types throughout PDFium.

core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.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 "../../../include/fpdfapi/fpdf_parser.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include <limits.h>
 #define _STREAM_MAX_SIZE_               20 * 1024 * 1024
-FX_DWORD _A85Decode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+FX_DWORD _A85Decode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     dest_size = 0;
     dest_buf = NULL;
     if (src_size == 0) {
         return 0;
     }
     FX_DWORD zcount = 0;
     FX_DWORD pos = 0;
     while (pos < src_size) {
-        FX_BYTE ch = src_buf[pos];
+        uint8_t ch = src_buf[pos];
         if (ch < '!' && ch != '\n' && ch != '\r' && ch != ' ' && ch != '\t') {
             break;
         }
         if (ch == 'z') {
             zcount ++;
         } else if (ch > 'u') {
             break;
         }
         pos ++;
     }
     if (pos == 0) {
         return 0;
     }
     if (zcount > UINT_MAX / 4) {
         return (FX_DWORD) - 1;
     }
     if (zcount * 4 > UINT_MAX - (pos - zcount)) {
         return (FX_DWORD) - 1;
     }
-    dest_buf = FX_Alloc(FX_BYTE, zcount * 4 + (pos - zcount));
+    dest_buf = FX_Alloc(uint8_t, zcount * 4 + (pos - zcount));
     int state = 0;
-    FX_UINT32 res = 0;
+    uint32_t res = 0;
     pos = dest_size = 0;
     while (pos < src_size) {
-        FX_BYTE ch = src_buf[pos++];
+        uint8_t ch = src_buf[pos++];
         if (ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {
             continue;
         }
         if (ch == 'z') {
             FXSYS_memset32(dest_buf + dest_size, 0, 4);
             state = 0;
             res = 0;
             dest_size += 4;
         } else {
             if (ch < '!' || ch > 'u') {
                 break;
             }
             res = res * 85 + ch - 33;
             state ++;
             if (state == 5) {
                 for (int i = 0; i < 4; i ++) {
-                    dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);
+                    dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8);
                 }
                 state = 0;
                 res = 0;
             }
         }
     }
     if (state) {
         int i;
         for (i = state; i < 5; i ++) {
             res = res * 85 + 84;
         }
         for (i = 0; i < state - 1; i ++) {
-            dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);
+            dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8);
         }
     }
     if (pos < src_size && src_buf[pos] == '>') {
         pos ++;
     }
     return pos;
 }
-FX_DWORD _HexDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+FX_DWORD _HexDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     FX_DWORD i;
     for (i = 0; i < src_size; i ++)
         if (src_buf[i] == '>') {
             break;
         }
-    dest_buf = FX_Alloc( FX_BYTE, i / 2 + 1);
+    dest_buf = FX_Alloc( uint8_t, i / 2 + 1);
     dest_size = 0;
     FX_BOOL bFirstDigit = TRUE;
     for (i = 0; i < src_size; i ++) {
-        FX_BYTE ch = src_buf[i];
+        uint8_t ch = src_buf[i];
         if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') {
             continue;
         }
         int digit;
         if (ch <= '9' && ch >= '0') {
             digit = ch - '0';
         } else if (ch <= 'f' && ch >= 'a') {
             digit = ch - 'a' + 10;
         } else if (ch <= 'F' && ch >= 'A') {
             digit = ch - 'A' + 10;
         } else if (ch == '>') {
             i ++;
             break;
         } else {
             continue;
         }
         if (bFirstDigit) {
             dest_buf[dest_size] = digit * 16;
         } else {
             dest_buf[dest_size ++] += digit;
         }
         bFirstDigit = !bFirstDigit;
     }
     if (!bFirstDigit) {
         dest_size ++;
     }
     return i;
 }
-FX_DWORD RunLengthDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+FX_DWORD RunLengthDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     FX_DWORD i = 0;
     FX_DWORD old;
     dest_size = 0;
     while (i < src_size) {
         if (src_buf[i] < 128) {
             old = dest_size;
             dest_size += src_buf[i] + 1;
             if (dest_size < old) {
                 return (FX_DWORD) - 1;
             }
             i += src_buf[i] + 2;
         } else if (src_buf[i] > 128) {
             old = dest_size;
             dest_size += 257 - src_buf[i];
             if (dest_size < old) {
                 return (FX_DWORD) - 1;
             }
             i += 2;
         } else {
             break;
         }
     }
     if (dest_size >= _STREAM_MAX_SIZE_) {
         return -1;
     }
-    dest_buf = FX_Alloc( FX_BYTE, dest_size);
+    dest_buf = FX_Alloc( uint8_t, dest_size);
     i = 0;
     int dest_count = 0;
     while (i < src_size) {
         if (src_buf[i] < 128) {
             FX_DWORD copy_len = src_buf[i] + 1;
             FX_DWORD buf_left = src_size - i - 1;
             if (buf_left < copy_len) {
                 FX_DWORD delta = copy_len - buf_left;
                 copy_len = buf_left;
                 FXSYS_memset8(dest_buf + dest_count + copy_len, '\0', delta);
@@ skipping 75 matching lines @@
         Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);
         BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);
         Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1);
         if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
             return NULL;
         }
     }
     return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(src_buf, src_size, width, height,
             nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
 }
-FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const FX_BYTE* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
+FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
                                   FX_DWORD estimated_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     int predictor = 0;
     FX_BOOL bEarlyChange = TRUE;
     int Colors = 0, BitsPerComponent = 0, Columns = 0;
     if (pParams) {
         predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));
         bEarlyChange = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("EarlyChange"), 1);
         Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);
         BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);
@@ skipping 202 matching lines @@
     }
 
     int encLen = len * 2 + 2;
 
     FX_LPBYTE dest_buf2 = (FX_LPBYTE)result.GetBuffer(encLen);
     dest_buf2[0] = 0xfe;
     dest_buf2[1] = 0xff;
     dest_buf2 += 2;
     for (int i = 0; i < len; i ++) {
         *dest_buf2++ = pString[i] >> 8;
-        *dest_buf2++ = (FX_BYTE)pString[i];
+        *dest_buf2++ = (uint8_t)pString[i];
     }
     result.ReleaseBuffer(encLen);
     return result;
 }
 CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex)
 {
     CFX_ByteTextBuf result;
     int srclen = src.GetLength();
     if (bHex) {
         result.AppendChar('<');
         for (int i = 0; i < srclen; i ++) {
             result.AppendChar("0123456789ABCDEF"[src[i] / 16]);
             result.AppendChar("0123456789ABCDEF"[src[i] % 16]);
         }
         result.AppendChar('>');
         return result.GetByteString();
     }
     result.AppendChar('(');
     for (int i = 0; i < srclen; i ++) {
-        FX_BYTE ch = src[i];
+        uint8_t ch = src[i];
         if (ch == ')' || ch == '\\' || ch == '(') {
             result.AppendChar('\\');
         } else if (ch == 0x0a) {
             result << FX_BSTRC("\\n");
             continue;
         } else if (ch == 0x0d) {
             result << FX_BSTRC("\\r");
             continue;
         }
         result.AppendChar(ch);
     }
     result.AppendChar(')');
     return result.GetByteString();
 }
-void FlateEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
     if (pEncoders) {
         pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, dest_size);
     }
 }
 void FlateEncode(FX_LPCBYTE src_buf, FX_DWORD src_size, int predictor, int Colors, int BitsPerComponent, int Columns,
                  FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
     if (pEncoders) {
         pEncoders->GetFlateModule()->Encode(src_buf, src_size, predictor, Colors, BitsPerComponent, Columns, dest_buf, dest_size);
     }
 }
-FX_DWORD FlateDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+FX_DWORD FlateDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
     if (pEncoders) {
         return pEncoders->GetFlateModule()->FlateOrLZWDecode(FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
     }
     return 0;
 }