Merge to XFA: Use stdint.h types throughout PDFium.

xfa/src/fxbarcode/qrcode/BC_QRCoderEncoder.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
 // Original code is licensed as follows:
 /*
  * Copyright 2008 ZXing authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ skipping 18 matching lines @@
 #include "BC_QRCoder.h"
 #include "BC_QRCoderEncoder.h"
 #include "BC_QRCoderMode.h"
 #include "BC_QRCoderEncoder.h"
 #include "BC_QRCoderECBlocks.h"
 #include "BC_QRCoderVersion.h"
 #include "BC_QRCoderBlockPair.h"
 #include "BC_QRCoderMaskUtil.h"
 #include "BC_QRCoderMatrixUtil.h"
 #include "BC_QRCoderBitVector.h"
-const FX_INT32 CBC_QRCoderEncoder::m_alphaNumbericTable[] = {
+const int32_t CBC_QRCoderEncoder::m_alphaNumbericTable[] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
     0,   1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
     25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1
 };
 CBC_QRCoderEncoder::CBC_QRCoderEncoder()
 {
 }
@@ skipping 14 matching lines @@
         }
         m_mode = mode_string.m_mode;
         m_string = mode_string.m_string;
         return *this;
     }
 public:
     Make_Pair(CBC_QRCoderMode *mode, const CFX_ByteString &str): m_mode(mode), m_string(str) {}
     ~Make_Pair() {}
 };
 void CBC_QRCoderEncoder::Encode(const CFX_ByteString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel,
-                                CBC_QRCoder *qrCode, FX_INT32 &e, FX_INT32 versionSpecify)
+                                CBC_QRCoder *qrCode, int32_t &e, int32_t versionSpecify)
 {
     if(versionSpecify == 0) {
         EncodeWithAutoVersion(content, ecLevel, qrCode, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e)
     } else if(versionSpecify > 0 && versionSpecify <= 40) {
         EncodeWithSpecifyVersion(content, ecLevel, qrCode, versionSpecify, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else {
         e = BCExceptionVersionMust1_40;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
 void CBC_QRCoderEncoder::AppendECI(CBC_QRCoderBitVector* bits)
 {
 }
 void CBC_QRCoderEncoder::AppendDataModeLenghInfo(CFX_PtrArray &splitResult, CBC_QRCoderBitVector &headerAndDataBits,
-        CBC_QRCoderMode *tempMode, CBC_QRCoder *qrCode, CFX_ByteString &encoding, FX_INT32 &e)
+        CBC_QRCoderMode *tempMode, CBC_QRCoder *qrCode, CFX_ByteString &encoding, int32_t &e)
 {
-    for(FX_INT32 i = 0; i < splitResult.GetSize(); i++) {
+    for(int32_t i = 0; i < splitResult.GetSize(); i++) {
         tempMode = ((Make_Pair*)splitResult[i])->m_mode;
         if(tempMode == CBC_QRCoderMode::sGBK) {
             AppendModeInfo(tempMode, &headerAndDataBits, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             AppendLengthInfo(((Make_Pair*)splitResult[i])->m_string.GetLength(), qrCode->GetVersion(), tempMode, &headerAndDataBits, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             AppendBytes(((Make_Pair*)splitResult[i])->m_string, tempMode, &headerAndDataBits, encoding, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         } else if(tempMode == CBC_QRCoderMode::sBYTE) {
             CFX_ByteArray bytes;
@@ skipping 19 matching lines @@
             AppendBytes(((Make_Pair*)splitResult[i])->m_string, tempMode, &headerAndDataBits, encoding, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         } else {
             e = BCExceptionUnknown;
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         }
     }
 }
 void CBC_QRCoderEncoder::SplitString(const CFX_ByteString &content, CFX_PtrArray &result)
 {
-    FX_INT32 index = 0, flag = 0;
-    while((((FX_BYTE)content[index] >= 0xA1 && (FX_BYTE)content[index] <= 0xAA) ||
-            ((FX_BYTE)content[index] >= 0xB0 && (FX_BYTE)content[index] <= 0xFA)) && (index < content.GetLength())) {
+    int32_t index = 0, flag = 0;
+    while((((uint8_t)content[index] >= 0xA1 && (uint8_t)content[index] <= 0xAA) ||
+            ((uint8_t)content[index] >= 0xB0 && (uint8_t)content[index] <= 0xFA)) && (index < content.GetLength())) {
         index += 2;
     }
     if(index != flag) {
         result.Add(FX_NEW Make_Pair(CBC_QRCoderMode::sGBK, content.Mid(flag, index - flag)));
     }
     flag = index;
     if(index >= content.GetLength()) {
         return;
     }
-    while(GetAlphaNumericCode((FX_BYTE)content[index]) == -1
-            && !(((FX_BYTE)content[index] >= 0xA1 && (FX_BYTE)content[index] <= 0xAA) ||
-                 ((FX_BYTE)content[index] >= 0xB0 && (FX_BYTE)content[index] <= 0xFA))
+    while(GetAlphaNumericCode((uint8_t)content[index]) == -1
+            && !(((uint8_t)content[index] >= 0xA1 && (uint8_t)content[index] <= 0xAA) ||
+                 ((uint8_t)content[index] >= 0xB0 && (uint8_t)content[index] <= 0xFA))
             && (index < content.GetLength())) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-        if(IsDBCSLeadByte((FX_BYTE)content[index]))
+        if(IsDBCSLeadByte((uint8_t)content[index]))
 #else
-        if((FX_BYTE)content[index] > 127)
+        if((uint8_t)content[index] > 127)
 #endif
         {
             index += 2;
         } else {
             index++;
         }
     }
     if(index != flag) {
         result.Add(FX_NEW Make_Pair(CBC_QRCoderMode::sBYTE, content.Mid(flag, index - flag)));
     }
     flag = index;
     if(index >= content.GetLength()) {
         return;
     }
-    while(FXSYS_Isdigit((FX_BYTE)content[index]) && (index < content.GetLength())) {
+    while(FXSYS_Isdigit((uint8_t)content[index]) && (index < content.GetLength())) {
         index++;
     }
     if(index != flag) {
         result.Add(FX_NEW Make_Pair(CBC_QRCoderMode::sNUMERIC, content.Mid(flag, index - flag)));
     }
     flag = index;
     if(index >= content.GetLength()) {
         return;
     }
-    while(GetAlphaNumericCode((FX_BYTE)content[index]) != -1  && (index < content.GetLength())) {
+    while(GetAlphaNumericCode((uint8_t)content[index]) != -1  && (index < content.GetLength())) {
         index++;
     }
     if(index != flag) {
         result.Add(FX_NEW Make_Pair(CBC_QRCoderMode::sALPHANUMERIC, content.Mid(flag, index - flag)));
     }
     flag = index;
     if(index >= content.GetLength()) {
         return;
     }
     SplitString(content.Mid(index, content.GetLength() - index), result);
 }
-FX_INT32 CBC_QRCoderEncoder::GetSpanByVersion(CBC_QRCoderMode *modeFirst, CBC_QRCoderMode *modeSecond, FX_INT32 versionNum, FX_INT32 &e)
+int32_t CBC_QRCoderEncoder::GetSpanByVersion(CBC_QRCoderMode *modeFirst, CBC_QRCoderMode *modeSecond, int32_t versionNum, int32_t &e)
 {
     if(versionNum == 0) {
         return 0;
     }
     if((modeFirst == CBC_QRCoderMode::sALPHANUMERIC)
             && (modeSecond == CBC_QRCoderMode::sBYTE)) {
         if(versionNum >= 1 && versionNum <= 9) {
             return 11;
         } else if(versionNum >= 10 && versionNum <= 26) {
             return 15;
@@ skipping 23 matching lines @@
             return 8;
         } else if(versionNum >= 27 && versionNum <= 40) {
             return 9;
         } else {
             e = BCExceptionNoSuchVersion;
             BC_EXCEPTION_CHECK_ReturnValue(e, 0);
         }
     }
     return -1;
 }
-void CBC_QRCoderEncoder::MergeString(CFX_PtrArray &result, FX_INT32 versionNum, FX_INT32 &e)
+void CBC_QRCoderEncoder::MergeString(CFX_PtrArray &result, int32_t versionNum, int32_t &e)
 {
     Make_Pair *first = NULL;
     Make_Pair *second = NULL;
     size_t mergeNum = 0;
-    FX_INT32 i;
+    int32_t i;
     for(i = 0; ((i < result.GetSize()) && (i + 1 < result.GetSize())); i++) {
         first = (Make_Pair*)result[i];
         second = (Make_Pair*)result[i + 1];
         if(first->m_mode == CBC_QRCoderMode::sALPHANUMERIC) {
-            FX_INT32 tmp = GetSpanByVersion(CBC_QRCoderMode::sALPHANUMERIC, CBC_QRCoderMode::sBYTE, versionNum, e);
+            int32_t tmp = GetSpanByVersion(CBC_QRCoderMode::sALPHANUMERIC, CBC_QRCoderMode::sBYTE, versionNum, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             if((second->m_mode == CBC_QRCoderMode::sBYTE)
                     && (first->m_string.GetLength() < tmp)) {
                 CFX_ByteString str = first->m_string + second->m_string;
                 second->m_string = str;
                 delete first;
                 result.RemoveAt(i);
                 i--;
                 mergeNum++;
             }
         } else if(first->m_mode == CBC_QRCoderMode::sBYTE) {
             if(second->m_mode == CBC_QRCoderMode::sBYTE) {
                 first->m_string += second->m_string;
                 delete second;
                 result.RemoveAt(i + 1);
                 i--;
                 mergeNum++;
             }
         } else if(first->m_mode == CBC_QRCoderMode::sNUMERIC) {
-            FX_INT32 tmp = GetSpanByVersion(CBC_QRCoderMode::sNUMERIC, CBC_QRCoderMode::sBYTE, versionNum, e);
+            int32_t tmp = GetSpanByVersion(CBC_QRCoderMode::sNUMERIC, CBC_QRCoderMode::sBYTE, versionNum, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             if((second->m_mode == CBC_QRCoderMode::sBYTE)
                     && (first->m_string.GetLength() < tmp)) {
                 CFX_ByteString str = first->m_string + second->m_string;
                 second->m_string = str;
                 delete first;
                 result.RemoveAt(i);
                 i--;
                 mergeNum++;
             }
             tmp = GetSpanByVersion(CBC_QRCoderMode::sNUMERIC, CBC_QRCoderMode::sALPHANUMERIC, versionNum, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             if((second->m_mode == CBC_QRCoderMode::sALPHANUMERIC)
                     && (first->m_string.GetLength() < tmp)) {
                 CFX_ByteString str = first->m_string + second->m_string;
                 second->m_string = str;
                 delete first;
                 result.RemoveAt(i);
                 i--;
                 mergeNum++;
             }
         }
     }
     if(mergeNum == 0) {
         return;
     }
     MergeString(result, versionNum, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
 }
-void CBC_QRCoderEncoder::InitQRCode(FX_INT32 numInputBytes, FX_INT32 versionNumber,
-                                    CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoderMode* mode, CBC_QRCoder* qrCode, FX_INT32 &e)
+void CBC_QRCoderEncoder::InitQRCode(int32_t numInputBytes, int32_t versionNumber,
+                                    CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoderMode* mode, CBC_QRCoder* qrCode, int32_t &e)
 {
     qrCode->SetECLevel(ecLevel);
     qrCode->SetMode(mode);
     CBC_QRCoderVersion* version = CBC_QRCoderVersion::GetVersionForNumber(versionNumber, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
-    FX_INT32 numBytes = version->GetTotalCodeWords();
+    int32_t numBytes = version->GetTotalCodeWords();
     CBC_QRCoderECBlocks* ecBlocks = version->GetECBlocksForLevel(ecLevel);
-    FX_INT32 numEcBytes = ecBlocks->GetTotalECCodeWords();
-    FX_INT32 numRSBlocks = ecBlocks->GetNumBlocks();
-    FX_INT32 numDataBytes = numBytes - numEcBytes;
+    int32_t numEcBytes = ecBlocks->GetTotalECCodeWords();
+    int32_t numRSBlocks = ecBlocks->GetNumBlocks();
+    int32_t numDataBytes = numBytes - numEcBytes;
     if(numDataBytes >= numInputBytes + 3) {
         qrCode->SetVersion(versionNumber);
         qrCode->SetNumTotalBytes(numBytes);
         qrCode->SetNumDataBytes(numDataBytes);
         qrCode->SetNumRSBlocks(numRSBlocks);
         qrCode->SetNumECBytes(numEcBytes);
         qrCode->SetMatrixWidth(version->GetDimensionForVersion());
         return;
     }
     e = BCExceptionCannotFindBlockInfo;
     BC_EXCEPTION_CHECK_ReturnVoid(e);
 }
 void CBC_QRCoderEncoder::EncodeWithSpecifyVersion(const CFX_ByteString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel,
-        CBC_QRCoder *qrCode, FX_INT32 versionSpecify, FX_INT32 &e)
+        CBC_QRCoder *qrCode, int32_t versionSpecify, int32_t &e)
 {
     CFX_ByteString encoding = "utf8";
     CBC_QRCoderMode *mode = CBC_QRCoderMode::sBYTE;
     CFX_PtrArray splitResult;
     CBC_QRCoderBitVector dataBits;
     dataBits.Init();
     SplitString(content, splitResult);
     MergeString(splitResult, versionSpecify, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
     CBC_QRCoderMode *tempMode = NULL;
-    for(FX_INT32 i = 0; i < splitResult.GetSize(); i++) {
+    for(int32_t i = 0; i < splitResult.GetSize(); i++) {
         AppendBytes(((Make_Pair*)splitResult[i])->m_string, ((Make_Pair*)splitResult[i])->m_mode, &dataBits, encoding, e);
         if(e != BCExceptionNO) {
-            for(FX_INT32 y = 0; y < splitResult.GetSize(); y++) {
+            for(int32_t y = 0; y < splitResult.GetSize(); y++) {
                 delete (Make_Pair*)splitResult[y];
             }
             splitResult.RemoveAll();
             return;
         }
     }
-    FX_INT32 numInputBytes = dataBits.sizeInBytes();
+    int32_t numInputBytes = dataBits.sizeInBytes();
     CBC_QRCoderBitVector headerAndDataBits;
     headerAndDataBits.Init();
     InitQRCode(numInputBytes, versionSpecify, ecLevel, mode, qrCode, e);
     if(e != BCExceptionNO) {
-        for(FX_INT32 k = 0; k < splitResult.GetSize(); k++) {
+        for(int32_t k = 0; k < splitResult.GetSize(); k++) {
             delete (Make_Pair*)splitResult[k];
         }
         splitResult.RemoveAll();
         return ;
     }
     AppendDataModeLenghInfo(splitResult, headerAndDataBits, tempMode, qrCode, encoding, e);
     if(e != BCExceptionNO) {
-        for(FX_INT32 k = 0; k < splitResult.GetSize(); k++) {
+        for(int32_t k = 0; k < splitResult.GetSize(); k++) {
             delete (Make_Pair*)splitResult[k];
         }
         splitResult.RemoveAll();
         return ;
     }
     numInputBytes = headerAndDataBits.sizeInBytes();
     TerminateBits(qrCode->GetNumDataBytes(), &headerAndDataBits, e);
     if(e != BCExceptionNO) {
-        for(FX_INT32 k = 0; k < splitResult.GetSize(); k++) {
+        for(int32_t k = 0; k < splitResult.GetSize(); k++) {
             delete (Make_Pair*)splitResult[k];
         }
         splitResult.RemoveAll();
         return ;
     }
-    for(FX_INT32 j = 0; j < splitResult.GetSize(); j++) {
+    for(int32_t j = 0; j < splitResult.GetSize(); j++) {
         delete (Make_Pair*)splitResult[j];
     }
     splitResult.RemoveAll();
     CBC_QRCoderBitVector finalBits ;
     finalBits.Init();
     InterleaveWithECBytes(&headerAndDataBits, qrCode->GetNumTotalBytes(), qrCode->GetNumDataBytes(),
                           qrCode->GetNumRSBlocks(), &finalBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_CommonByteMatrix* pDecoder = FX_NEW CBC_CommonByteMatrix(qrCode->GetMatrixWidth(), qrCode->GetMatrixWidth());
     pDecoder->Init();
     CBC_AutoPtr<CBC_CommonByteMatrix> matrix(pDecoder);
-    FX_INT32 maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
+    int32_t maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     qrCode->SetMaskPattern(maskPattern);
     CBC_QRCoderMatrixUtil::BuildMatrix(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), qrCode->GetMaskPattern(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     qrCode->SetMatrix(matrix.release());
     if(!qrCode->IsValid()) {
         e = BCExceptionInvalidQRCode;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::EncodeWithAutoVersion(const CFX_ByteString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoder *qrCode, FX_INT32 &e)
+void CBC_QRCoderEncoder::EncodeWithAutoVersion(const CFX_ByteString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoder *qrCode, int32_t &e)
 {
     CFX_ByteString encoding = "utf8";
     CBC_QRCoderMode *mode = CBC_QRCoderMode::sBYTE;
     CFX_PtrArray splitResult;
     CBC_QRCoderBitVector dataBits;
     dataBits.Init();
     SplitString(content, splitResult);
     MergeString(splitResult, 8, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_QRCoderMode *tempMode = NULL;
-    for(FX_INT32 i = 0; i < splitResult.GetSize(); i++) {
+    for(int32_t i = 0; i < splitResult.GetSize(); i++) {
         AppendBytes(((Make_Pair*)splitResult[i])->m_string, ((Make_Pair*)splitResult[i])->m_mode, &dataBits, encoding, e);
         if(e != BCExceptionNO) {
-            for(FX_INT32 l = 0; l < splitResult.GetSize(); l++) {
+            for(int32_t l = 0; l < splitResult.GetSize(); l++) {
                 delete (Make_Pair*)splitResult[l];
             }
             splitResult.RemoveAll();
             return;
         }
     }
-    FX_INT32 numInputBytes = dataBits.sizeInBytes();
+    int32_t numInputBytes = dataBits.sizeInBytes();
     InitQRCode(numInputBytes, ecLevel, mode, qrCode, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
     CBC_QRCoderBitVector headerAndDataBits;
     headerAndDataBits.Init();
     tempMode = NULL;
-    FX_INT32 versionNum = qrCode->GetVersion();
+    int32_t versionNum = qrCode->GetVersion();
 sign:
     AppendDataModeLenghInfo(splitResult, headerAndDataBits, tempMode, qrCode, encoding, e);
     if (e != BCExceptionNO) {
         goto catchException;
     }
     numInputBytes = headerAndDataBits.sizeInBytes();
     TerminateBits(qrCode->GetNumDataBytes(), &headerAndDataBits, e);
     if (e != BCExceptionNO) {
         goto catchException;
     }
 catchException:
     if (e != BCExceptionNO) {
-        FX_INT32 e1 = BCExceptionNO;
+        int32_t e1 = BCExceptionNO;
         InitQRCode(numInputBytes, ecLevel, mode, qrCode, e1);
         if (e1 != BCExceptionNO) {
             e = e1;
             return;
         }
         versionNum++;
         if (versionNum <= 40) {
             headerAndDataBits.Clear();
             e = BCExceptionNO;
             goto sign;
         } else {
-            for (FX_INT32 j = 0; j < splitResult.GetSize(); j++) {
+            for (int32_t j = 0; j < splitResult.GetSize(); j++) {
                 delete (Make_Pair*)splitResult[j];
             }
             splitResult.RemoveAll();
             return;
         }
     }
-    for (FX_INT32 k = 0; k < splitResult.GetSize(); k++) {
+    for (int32_t k = 0; k < splitResult.GetSize(); k++) {
         delete (Make_Pair*)splitResult[k];
     }
     splitResult.RemoveAll();
     CBC_QRCoderBitVector finalBits ;
     finalBits.Init();
     InterleaveWithECBytes(&headerAndDataBits, qrCode->GetNumTotalBytes(), qrCode->GetNumDataBytes(),
                           qrCode->GetNumRSBlocks(), &finalBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_CommonByteMatrix* pDecoder = FX_NEW CBC_CommonByteMatrix(qrCode->GetMatrixWidth(), qrCode->GetMatrixWidth());
     pDecoder->Init();
     CBC_AutoPtr<CBC_CommonByteMatrix> matrix(pDecoder);
-    FX_INT32 maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
+    int32_t maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     qrCode->SetMaskPattern(maskPattern);
     CBC_QRCoderMatrixUtil::BuildMatrix(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), qrCode->GetMaskPattern(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
     qrCode->SetMatrix(matrix.release());
     if(!qrCode->IsValid()) {
         e = BCExceptionInvalidQRCode;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::Encode(const CFX_WideString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoder *qrCode, FX_INT32 &e)
+void CBC_QRCoderEncoder::Encode(const CFX_WideString &content, CBC_QRCoderErrorCorrectionLevel* ecLevel, CBC_QRCoder *qrCode, int32_t &e)
 {
     CFX_ByteString encoding = "utf8";
     CFX_ByteString utf8Data;
     CBC_UtilCodingConvert::UnicodeToUTF8(content, utf8Data);
     CBC_QRCoderMode* mode = ChooseMode(utf8Data, encoding);
     CBC_QRCoderBitVector dataBits;
     dataBits.Init();
     AppendBytes(utf8Data, mode, &dataBits, encoding, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
-    FX_INT32 numInputBytes = dataBits.sizeInBytes();
+    int32_t numInputBytes = dataBits.sizeInBytes();
     InitQRCode(numInputBytes, ecLevel, mode, qrCode, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_QRCoderBitVector headerAndDataBits;
     headerAndDataBits.Init();
     AppendModeInfo(mode, &headerAndDataBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
-    FX_INT32 numLetters = mode == CBC_QRCoderMode::sBYTE ? dataBits.sizeInBytes() : content.GetLength();
+    int32_t numLetters = mode == CBC_QRCoderMode::sBYTE ? dataBits.sizeInBytes() : content.GetLength();
     AppendLengthInfo(numLetters, qrCode->GetVersion(), mode, &headerAndDataBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     headerAndDataBits.AppendBitVector(&dataBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
     TerminateBits(qrCode->GetNumDataBytes(), &headerAndDataBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_QRCoderBitVector finalBits ;
     finalBits.Init();
     InterleaveWithECBytes(&headerAndDataBits, qrCode->GetNumTotalBytes(), qrCode->GetNumDataBytes(),
                           qrCode->GetNumRSBlocks(), &finalBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     CBC_CommonByteMatrix* pDecoder = FX_NEW CBC_CommonByteMatrix(qrCode->GetMatrixWidth(), qrCode->GetMatrixWidth());
     pDecoder->Init();
     CBC_AutoPtr<CBC_CommonByteMatrix> matrix(pDecoder);
-    FX_INT32 maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
+    int32_t maskPattern = ChooseMaskPattern(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     qrCode->SetMaskPattern(maskPattern);
     CBC_QRCoderMatrixUtil::BuildMatrix(&finalBits, qrCode->GetECLevel(), qrCode->GetVersion(), qrCode->GetMaskPattern(), matrix.get(), e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
     qrCode->SetMatrix(matrix.release());
     if(!qrCode->IsValid()) {
         e = BCExceptionInvalidQRCode;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::TerminateBits(FX_INT32 numDataBytes, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::TerminateBits(int32_t numDataBytes, CBC_QRCoderBitVector* bits, int32_t &e)
 {
-    FX_INT32 capacity = numDataBytes << 3;
+    int32_t capacity = numDataBytes << 3;
     if(bits->Size() > capacity) {
         e = BCExceptionDataTooMany;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
-    for (FX_INT32 i = 0; i < 4 && bits->Size() < capacity; ++i) {
+    for (int32_t i = 0; i < 4 && bits->Size() < capacity; ++i) {
         bits->AppendBit(0, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
-    FX_INT32 numBitsInLastByte = bits->Size() % 8;
+    int32_t numBitsInLastByte = bits->Size() % 8;
     if (numBitsInLastByte > 0) {
-        FX_INT32 numPaddingBits = 8 - numBitsInLastByte;
-        for (FX_INT32 j = 0; j < numPaddingBits; ++j) {
+        int32_t numPaddingBits = 8 - numBitsInLastByte;
+        for (int32_t j = 0; j < numPaddingBits; ++j) {
             bits->AppendBit(0, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e)
         }
     }
     if (bits->Size() % 8 != 0) {
         e = BCExceptionDigitLengthMustBe8;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
-    FX_INT32 numPaddingBytes = numDataBytes - bits->sizeInBytes();
-    for (FX_INT32 k = 0; k < numPaddingBytes; ++k) {
+    int32_t numPaddingBytes = numDataBytes - bits->sizeInBytes();
+    for (int32_t k = 0; k < numPaddingBytes; ++k) {
         if (k % 2 == 0) {
             bits->AppendBits(0xec, 8, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         } else {
             bits->AppendBits(0x11, 8, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         }
     }
     if (bits->Size() != capacity) {
         e = BCExceptionBitsNotEqualCacity;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-FX_INT32 CBC_QRCoderEncoder::ChooseMaskPattern(CBC_QRCoderBitVector* bits, CBC_QRCoderErrorCorrectionLevel* ecLevel, FX_INT32 version, CBC_CommonByteMatrix* matrix, FX_INT32 &e)
+int32_t CBC_QRCoderEncoder::ChooseMaskPattern(CBC_QRCoderBitVector* bits, CBC_QRCoderErrorCorrectionLevel* ecLevel, int32_t version, CBC_CommonByteMatrix* matrix, int32_t &e)
 {
-    FX_INT32 minPenalty = 65535;
-    FX_INT32 bestMaskPattern = -1;
-    for(FX_INT32 maskPattern = 0; maskPattern < CBC_QRCoder::NUM_MASK_PATTERNS; maskPattern++) {
+    int32_t minPenalty = 65535;
+    int32_t bestMaskPattern = -1;
+    for(int32_t maskPattern = 0; maskPattern < CBC_QRCoder::NUM_MASK_PATTERNS; maskPattern++) {
         CBC_QRCoderMatrixUtil::BuildMatrix(bits, ecLevel, version, maskPattern, matrix, e);
         BC_EXCEPTION_CHECK_ReturnValue(e, 0);
-        FX_INT32 penalty = CalculateMaskPenalty(matrix);
+        int32_t penalty = CalculateMaskPenalty(matrix);
         if(penalty < minPenalty) {
             minPenalty = penalty;
             bestMaskPattern = maskPattern;
         }
     }
     return bestMaskPattern;
 }
-FX_INT32 CBC_QRCoderEncoder::CalculateMaskPenalty(CBC_CommonByteMatrix* matrix)
+int32_t CBC_QRCoderEncoder::CalculateMaskPenalty(CBC_CommonByteMatrix* matrix)
 {
-    FX_INT32 penalty = 0;
+    int32_t penalty = 0;
     penalty += CBC_QRCoderMaskUtil::ApplyMaskPenaltyRule1(matrix);
     penalty += CBC_QRCoderMaskUtil::ApplyMaskPenaltyRule2(matrix);
     penalty += CBC_QRCoderMaskUtil::ApplyMaskPenaltyRule3(matrix);
     penalty += CBC_QRCoderMaskUtil::ApplyMaskPenaltyRule4(matrix);
     return penalty;
 }
 CBC_QRCoderMode *CBC_QRCoderEncoder::ChooseMode(const CFX_ByteString &content, CFX_ByteString encoding)
 {
     if(encoding.Compare("SHIFT_JIS") == 0) {
         return CBC_QRCoderMode::sKANJI;
     }
     FX_BOOL hasNumeric = FALSE;
     FX_BOOL hasAlphaNumeric = FALSE;
-    for(FX_INT32 i = 0; i < content.GetLength(); i++) {
-        if(isdigit((FX_BYTE)content[i])) {
+    for(int32_t i = 0; i < content.GetLength(); i++) {
+        if(isdigit((uint8_t)content[i])) {
             hasNumeric = TRUE;
-        } else if(GetAlphaNumericCode((FX_BYTE)content[i]) != -1) {
+        } else if(GetAlphaNumericCode((uint8_t)content[i]) != -1) {
             hasAlphaNumeric = TRUE;
         } else {
             return CBC_QRCoderMode::sBYTE;
         }
     }
     if(hasAlphaNumeric) {
         return CBC_QRCoderMode::sALPHANUMERIC;
     } else if(hasNumeric) {
         return CBC_QRCoderMode::sNUMERIC;
     }
     return CBC_QRCoderMode::sBYTE;
 }
-FX_INT32 CBC_QRCoderEncoder::GetAlphaNumericCode(FX_INT32 code)
+int32_t CBC_QRCoderEncoder::GetAlphaNumericCode(int32_t code)
 {
     if(code < 96 && code >= 0) {
         return m_alphaNumbericTable[code];
     }
     return -1;
 }
-void CBC_QRCoderEncoder::AppendBytes(const CFX_ByteString &content, CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, CFX_ByteString encoding, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendBytes(const CFX_ByteString &content, CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, CFX_ByteString encoding, int32_t &e)
 {
     if(mode == CBC_QRCoderMode::sNUMERIC) {
         AppendNumericBytes(content, bits, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if(mode == CBC_QRCoderMode::sALPHANUMERIC) {
         AppendAlphaNumericBytes(content, bits, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if(mode == CBC_QRCoderMode::sBYTE) {
         Append8BitBytes(content, bits, encoding, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if(mode == CBC_QRCoderMode::sKANJI) {
         AppendKanjiBytes(content, bits, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if(mode == CBC_QRCoderMode::sGBK) {
         AppendGBKBytes(content, bits, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else {
         e = BCExceptionUnsupportedMode;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::AppendNumericBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendNumericBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, int32_t &e)
 {
-    FX_INT32 length = content.GetLength();
-    FX_INT32 i = 0;
+    int32_t length = content.GetLength();
+    int32_t i = 0;
     while(i < length) {
-        FX_INT32 num1 = content[i] - '0';
+        int32_t num1 = content[i] - '0';
         if(i + 2 < length) {
-            FX_INT32 num2 = content[i + 1] - '0';
-            FX_INT32 num3 = content[i + 2] - '0';
+            int32_t num2 = content[i + 1] - '0';
+            int32_t num3 = content[i + 2] - '0';
             bits->AppendBits(num1 * 100 + num2 * 10 + num3, 10, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e)
             i += 3;
         } else if(i + 1 < length) {
-            FX_INT32 num2 = content[i + 1] - '0';
+            int32_t num2 = content[i + 1] - '0';
             bits->AppendBits(num1 * 10 + num2, 7, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e)
             i += 2;
         } else {
             bits->AppendBits(num1, 4, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             i++;
         }
     }
 }
-void CBC_QRCoderEncoder::AppendAlphaNumericBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendAlphaNumericBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, int32_t &e)
 {
-    FX_INT32 length = content.GetLength();
-    FX_INT32 i = 0;
+    int32_t length = content.GetLength();
+    int32_t i = 0;
     while(i < length) {
-        FX_INT32 code1 = GetAlphaNumericCode(content[i]);
+        int32_t code1 = GetAlphaNumericCode(content[i]);
         if(code1 == -1) {
             e = BCExceptionInvalidateCharacter;
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         }
         if(i + 1 < length) {
-            FX_INT32 code2 = GetAlphaNumericCode(content[i + 1]);
+            int32_t code2 = GetAlphaNumericCode(content[i + 1]);
             if(code2 == -1) {
                 e = BCExceptionInvalidateCharacter;
                 BC_EXCEPTION_CHECK_ReturnVoid(e);
             }
             bits->AppendBits(code1 * 45 + code2, 11, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e);
             i += 2;
         } else {
             bits->AppendBits(code1, 6, e);
             BC_EXCEPTION_CHECK_ReturnVoid(e)
             i++;
         }
     }
 }
-void CBC_QRCoderEncoder::AppendGBKBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendGBKBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, int32_t &e)
 {
-    FX_INT32 length = content.GetLength();
+    int32_t length = content.GetLength();
     FX_DWORD value = 0;
-    for(FX_INT32 i = 0; i < length; i += 2) {
-        value = (FX_DWORD)((FX_BYTE)content[i] << 8 | (FX_BYTE)content[i + 1]);
+    for(int32_t i = 0; i < length; i += 2) {
+        value = (FX_DWORD)((uint8_t)content[i] << 8 | (uint8_t)content[i + 1]);
         if(value <= 0xAAFE && value >= 0xA1A1) {
             value -= 0xA1A1;
         } else if(value <= 0xFAFE && value >= 0xB0A1) {
             value -= 0xA6A1;
         } else {
             e = BCExceptionInvalidateCharacter;
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         }
         value = (FX_DWORD)((value >> 8 ) * 0x60) + (FX_DWORD)(value & 0xff);
         bits->AppendBits(value, 13, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::Append8BitBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, CFX_ByteString encoding, FX_INT32 &e)
+void CBC_QRCoderEncoder::Append8BitBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, CFX_ByteString encoding, int32_t &e)
 {
-    for(FX_INT32 i = 0; i < content.GetLength(); i++) {
+    for(int32_t i = 0; i < content.GetLength(); i++) {
         bits->AppendBits(content[i], 8, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::Append8BitBytes(CFX_ByteArray &bytes, CBC_QRCoderBitVector *bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::Append8BitBytes(CFX_ByteArray &bytes, CBC_QRCoderBitVector *bits, int32_t &e)
 {
-    for(FX_INT32 i = 0; i < bytes.GetSize(); i++) {
+    for(int32_t i = 0; i < bytes.GetSize(); i++) {
         bits->AppendBits(bytes[i], 8, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::AppendKanjiBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendKanjiBytes(const CFX_ByteString &content, CBC_QRCoderBitVector* bits, int32_t &e)
 {
     CFX_ByteArray bytes;
     FX_DWORD value = 0, h = 0;
-    for(FX_INT32 i = 0; i < bytes.GetSize(); i += 2) {
-        value = (FX_DWORD)((FX_BYTE)(content[i] << 8) | (FX_BYTE)content[i + 1]);
+    for(int32_t i = 0; i < bytes.GetSize(); i += 2) {
+        value = (FX_DWORD)((uint8_t)(content[i] << 8) | (uint8_t)content[i + 1]);
         if(value <= 0x9ffc && value >= 0x8140) {
             value -= 0x8140;
         } else if(value <= 0xebbf && value >= 0xe040) {
             value -= 0xc140;
         } else {
             e = BCExceptionInvalidateCharacter;
             BC_EXCEPTION_CHECK_ReturnVoid(e);
         }
         value = (FX_DWORD)((value >> 8 ) * 0xc0) + (FX_DWORD)(value & 0xff);
         bits->AppendBits(value, 13, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::InitQRCode(FX_INT32 numInputBytes, CBC_QRCoderErrorCorrectionLevel* ecLevel,
-                                    CBC_QRCoderMode* mode, CBC_QRCoder* qrCode, FX_INT32 &e)
+void CBC_QRCoderEncoder::InitQRCode(int32_t numInputBytes, CBC_QRCoderErrorCorrectionLevel* ecLevel,
+                                    CBC_QRCoderMode* mode, CBC_QRCoder* qrCode, int32_t &e)
 {
     qrCode->SetECLevel(ecLevel);
     qrCode->SetMode(mode);
-    for(FX_INT32 versionNum = 1; versionNum <= 40; versionNum++) {
+    for(int32_t versionNum = 1; versionNum <= 40; versionNum++) {
         CBC_QRCoderVersion* version = CBC_QRCoderVersion::GetVersionForNumber(versionNum, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
-        FX_INT32 numBytes = version->GetTotalCodeWords();
+        int32_t numBytes = version->GetTotalCodeWords();
         CBC_QRCoderECBlocks* ecBlocks = version->GetECBlocksForLevel(ecLevel);
-        FX_INT32 numEcBytes = ecBlocks->GetTotalECCodeWords();
-        FX_INT32 numRSBlocks = ecBlocks->GetNumBlocks();
-        FX_INT32 numDataBytes = numBytes - numEcBytes;
+        int32_t numEcBytes = ecBlocks->GetTotalECCodeWords();
+        int32_t numRSBlocks = ecBlocks->GetNumBlocks();
+        int32_t numDataBytes = numBytes - numEcBytes;
         if(numDataBytes >= numInputBytes + 3) {
             qrCode->SetVersion(versionNum);
             qrCode->SetNumTotalBytes(numBytes);
             qrCode->SetNumDataBytes(numDataBytes);
             qrCode->SetNumRSBlocks(numRSBlocks);
             qrCode->SetNumECBytes(numEcBytes);
             qrCode->SetMatrixWidth(version->GetDimensionForVersion());
             return;
         }
     }
     e = BCExceptionCannotFindBlockInfo;
     BC_EXCEPTION_CHECK_ReturnVoid(e);
 }
-void CBC_QRCoderEncoder::AppendModeInfo(CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendModeInfo(CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, int32_t &e)
 {
     bits->AppendBits(mode->GetBits(), 4, e);
     if(mode == CBC_QRCoderMode::sGBK) {
         bits->AppendBits(1, 4, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::AppendLengthInfo(FX_INT32 numLetters, FX_INT32 version, CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, FX_INT32 &e)
+void CBC_QRCoderEncoder::AppendLengthInfo(int32_t numLetters, int32_t version, CBC_QRCoderMode* mode, CBC_QRCoderBitVector* bits, int32_t &e)
 {
     CBC_QRCoderVersion* qcv = CBC_QRCoderVersion::GetVersionForNumber(version, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
-    FX_INT32 numBits = mode->GetCharacterCountBits(qcv, e);
+    int32_t numBits = mode->GetCharacterCountBits(qcv, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
     if(numBits > ((1 << numBits) - 1)) {
         return;
     }
     if(mode == CBC_QRCoderMode::sGBK) {
         bits->AppendBits(numLetters / 2, numBits, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
     bits->AppendBits(numLetters, numBits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
 }
-void CBC_QRCoderEncoder::InterleaveWithECBytes(CBC_QRCoderBitVector* bits, FX_INT32 numTotalBytes, FX_INT32 numDataBytes, FX_INT32 numRSBlocks, CBC_QRCoderBitVector* result, FX_INT32 &e)
+void CBC_QRCoderEncoder::InterleaveWithECBytes(CBC_QRCoderBitVector* bits, int32_t numTotalBytes, int32_t numDataBytes, int32_t numRSBlocks, CBC_QRCoderBitVector* result, int32_t &e)
 {
     if(bits->sizeInBytes() != numDataBytes) {
         e = BCExceptionBitsBytesNotMatch;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
-    FX_INT32 dataBytesOffset = 0;
-    FX_INT32 maxNumDataBytes = 0;
-    FX_INT32 maxNumEcBytes = 0;
+    int32_t dataBytesOffset = 0;
+    int32_t maxNumDataBytes = 0;
+    int32_t maxNumEcBytes = 0;
     CFX_PtrArray blocks;
-    FX_INT32 i;
+    int32_t i;
     for(i = 0; i < numRSBlocks; i++) {
-        FX_INT32 numDataBytesInBlock;
-        FX_INT32 numEcBytesInBlosk;
+        int32_t numDataBytesInBlock;
+        int32_t numEcBytesInBlosk;
         GetNumDataBytesAndNumECBytesForBlockID(numTotalBytes, numDataBytes, numRSBlocks, i,
                                                numDataBytesInBlock, numEcBytesInBlosk);
         CBC_CommonByteArray* dataBytes = FX_NEW CBC_CommonByteArray;
         dataBytes->Set(bits->GetArray(), dataBytesOffset, numDataBytesInBlock);
         CBC_CommonByteArray* ecBytes = GenerateECBytes(dataBytes, numEcBytesInBlosk, e);
         BC_EXCEPTION_CHECK_ReturnVoid(e);
         blocks.Add(FX_NEW CBC_QRCoderBlockPair(dataBytes, ecBytes));
         maxNumDataBytes = FX_MAX(maxNumDataBytes, dataBytes->Size());
         maxNumEcBytes = FX_MAX(maxNumEcBytes, ecBytes->Size());
         dataBytesOffset += numDataBytesInBlock;
     }
     if(numDataBytes != dataBytesOffset) {
         e = BCExceptionBytesNotMatchOffset;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
-    for(FX_INT32 x = 0; x < maxNumDataBytes; x++) {
-        for(FX_INT32 j = 0; j < blocks.GetSize(); j++) {
+    for(int32_t x = 0; x < maxNumDataBytes; x++) {
+        for(int32_t j = 0; j < blocks.GetSize(); j++) {
             CBC_CommonByteArray* dataBytes = ((CBC_QRCoderBlockPair*)blocks[j])->GetDataBytes();
             if(x < dataBytes->Size()) {
                 result->AppendBits(dataBytes->At(x), 8, e);
                 BC_EXCEPTION_CHECK_ReturnVoid(e);
             }
         }
     }
-    for(FX_INT32 y = 0; y < maxNumEcBytes; y++) {
-        for(FX_INT32 l = 0; l < blocks.GetSize(); l++) {
+    for(int32_t y = 0; y < maxNumEcBytes; y++) {
+        for(int32_t l = 0; l < blocks.GetSize(); l++) {
             CBC_CommonByteArray* ecBytes = ((CBC_QRCoderBlockPair*)blocks[l])->GetErrorCorrectionBytes();
             if(y < ecBytes->Size()) {
                 result->AppendBits(ecBytes->At(y), 8, e);
                 BC_EXCEPTION_CHECK_ReturnVoid(e);
             }
         }
     }
-    for(FX_INT32 k = 0; k < blocks.GetSize(); k++) {
+    for(int32_t k = 0; k < blocks.GetSize(); k++) {
         delete (CBC_QRCoderBlockPair*)blocks[k];
     }
     if(numTotalBytes != result->sizeInBytes()) {
         e = BCExceptionSizeInBytesDiffer;
         BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
 }
-void CBC_QRCoderEncoder::GetNumDataBytesAndNumECBytesForBlockID(FX_INT32 numTotalBytes, FX_INT32 numDataBytes,
-        FX_INT32 numRSBlocks, FX_INT32 blockID,
-        FX_INT32 &numDataBytesInBlock, FX_INT32& numECBytesInBlock)
+void CBC_QRCoderEncoder::GetNumDataBytesAndNumECBytesForBlockID(int32_t numTotalBytes, int32_t numDataBytes,
+        int32_t numRSBlocks, int32_t blockID,
+        int32_t &numDataBytesInBlock, int32_t& numECBytesInBlock)
 {
     if(blockID >= numRSBlocks) {
         return;
     }
-    FX_INT32 numRsBlocksInGroup2 = numTotalBytes % numRSBlocks;
-    FX_INT32 numRsBlocksInGroup1 = numRSBlocks - numRsBlocksInGroup2;
-    FX_INT32 numTotalBytesInGroup1 = numTotalBytes / numRSBlocks;
-    FX_INT32 numTotalBytesInGroup2 = numTotalBytesInGroup1 + 1;
-    FX_INT32 numDataBytesInGroup1 = numDataBytes / numRSBlocks;
-    FX_INT32 numDataBytesInGroup2 = numDataBytesInGroup1 + 1;
-    FX_INT32 numEcBytesInGroup1 = numTotalBytesInGroup1 - numDataBytesInGroup1;
-    FX_INT32 numEcBytesInGroup2 = numTotalBytesInGroup2 - numDataBytesInGroup2;
+    int32_t numRsBlocksInGroup2 = numTotalBytes % numRSBlocks;
+    int32_t numRsBlocksInGroup1 = numRSBlocks - numRsBlocksInGroup2;
+    int32_t numTotalBytesInGroup1 = numTotalBytes / numRSBlocks;
+    int32_t numTotalBytesInGroup2 = numTotalBytesInGroup1 + 1;
+    int32_t numDataBytesInGroup1 = numDataBytes / numRSBlocks;
+    int32_t numDataBytesInGroup2 = numDataBytesInGroup1 + 1;
+    int32_t numEcBytesInGroup1 = numTotalBytesInGroup1 - numDataBytesInGroup1;
+    int32_t numEcBytesInGroup2 = numTotalBytesInGroup2 - numDataBytesInGroup2;
     if (blockID < numRsBlocksInGroup1) {
         numDataBytesInBlock = numDataBytesInGroup1;
         numECBytesInBlock = numEcBytesInGroup1;
     } else {
         numDataBytesInBlock = numDataBytesInGroup2;
         numECBytesInBlock = numEcBytesInGroup2;
     }
 }
-CBC_CommonByteArray* CBC_QRCoderEncoder::GenerateECBytes(CBC_CommonByteArray* dataBytes, FX_INT32 numEcBytesInBlock, FX_INT32 &e)
+CBC_CommonByteArray* CBC_QRCoderEncoder::GenerateECBytes(CBC_CommonByteArray* dataBytes, int32_t numEcBytesInBlock, int32_t &e)
 {
-    FX_INT32 numDataBytes = dataBytes->Size();
+    int32_t numDataBytes = dataBytes->Size();
     CFX_Int32Array toEncode;
     toEncode.SetSize(numDataBytes + numEcBytesInBlock);
-    for(FX_INT32 i = 0; i < numDataBytes; i++) {
+    for(int32_t i = 0; i < numDataBytes; i++) {
         toEncode[i] = (dataBytes->At(i));
     }
     CBC_ReedSolomonEncoder encode(CBC_ReedSolomonGF256::QRCodeFild);
     encode.Init();
     encode.Encode(&toEncode, numEcBytesInBlock, e);
     BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
     CBC_CommonByteArray* ecBytes = FX_NEW CBC_CommonByteArray(numEcBytesInBlock);
-    for(FX_INT32 j = 0; j < numEcBytesInBlock; j++) {
+    for(int32_t j = 0; j < numEcBytesInBlock; j++) {
         ecBytes->Set(j, toEncode[numDataBytes + j]);
     }
     return ecBytes;
 }