自学教程：C++ FXSYS_memcpy函数代码示例

static	FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo, const uint8_t* icc_buf_ptr, FX_DWORD icc_length){    if(icc_buf_ptr == NULL || icc_length == 0) {        return FALSE;    }    FX_DWORD icc_segment_size = (JPEG_MARKER_MAXSIZE - 2 - JPEG_OVERHEAD_LEN);    FX_DWORD icc_segment_num = (icc_length / icc_segment_size) + 1;    if (icc_segment_num > 255)	{        return FALSE;    }    FX_DWORD icc_data_length = JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);    uint8_t* icc_data = FX_Alloc(uint8_t, icc_data_length);    FXSYS_memcpy(icc_data, "/x49/x43/x43/x5f/x50/x52/x4f/x46/x49/x4c/x45/x00", 12);    icc_data[13] = (uint8_t)icc_segment_num;    for (uint8_t i = 0; i < (icc_segment_num - 1); i++) {        icc_data[12] = i + 1;        FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + i * icc_segment_size, icc_segment_size);        jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, icc_data_length);    }    icc_data[12] = (uint8_t)icc_segment_num;    FX_DWORD icc_size = (icc_segment_num - 1) * icc_segment_size;    FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size, icc_length - icc_size);    jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, JPEG_OVERHEAD_LEN + icc_length - icc_size);    FX_Free(icc_data);    return TRUE;}

void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt,                                            FX_DWORD objnum,                                            FX_DWORD gennum,                                            const uint8_t* src_buf,                                            FX_DWORD src_size,                                            uint8_t* dest_buf,                                            FX_DWORD& dest_size) {  if (m_Cipher == FXCIPHER_NONE) {    FXSYS_memcpy(dest_buf, src_buf, src_size);    return;  }  uint8_t realkey[16];  int realkeylen = 16;  if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {    uint8_t key1[32];    FXSYS_memcpy(key1, m_EncryptKey, m_KeyLen);    key1[m_KeyLen + 0] = (uint8_t)objnum;    key1[m_KeyLen + 1] = (uint8_t)(objnum >> 8);    key1[m_KeyLen + 2] = (uint8_t)(objnum >> 16);    key1[m_KeyLen + 3] = (uint8_t)gennum;    key1[m_KeyLen + 4] = (uint8_t)(gennum >> 8);    FXSYS_memcpy(key1 + m_KeyLen, &objnum, 3);    FXSYS_memcpy(key1 + m_KeyLen + 3, &gennum, 2);    if (m_Cipher == FXCIPHER_AES) {      FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4);    }    CRYPT_MD5Generate(        key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);    realkeylen = m_KeyLen + 5;    if (realkeylen > 16) {      realkeylen = 16;    }  }

void CPDF_CryptoHandler::CryptBlock(bool bEncrypt,                                    uint32_t objnum,                                    uint32_t gennum,                                    const uint8_t* src_buf,                                    uint32_t src_size,                                    uint8_t* dest_buf,                                    uint32_t& dest_size) {  if (m_Cipher == FXCIPHER_NONE) {    FXSYS_memcpy(dest_buf, src_buf, src_size);    return;  }  uint8_t realkey[16];  int realkeylen = 16;  if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {    uint8_t key1[32];    PopulateKey(objnum, gennum, key1);    if (m_Cipher == FXCIPHER_AES) {      FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4);    }    CRYPT_MD5Generate(        key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);    realkeylen = m_KeyLen + 5;    if (realkeylen > 16) {      realkeylen = 16;    }  }  if (m_Cipher == FXCIPHER_AES) {    CRYPT_AESSetKey(m_pAESContext, 16, m_KeyLen == 32 ? m_EncryptKey : realkey,                    m_KeyLen, bEncrypt);    if (bEncrypt) {      uint8_t iv[16];      for (int i = 0; i < 16; i++) {        iv[i] = (uint8_t)rand();      }      CRYPT_AESSetIV(m_pAESContext, iv);      FXSYS_memcpy(dest_buf, iv, 16);      int nblocks = src_size / 16;      CRYPT_AESEncrypt(m_pAESContext, dest_buf + 16, src_buf, nblocks * 16);      uint8_t padding[16];      FXSYS_memcpy(padding, src_buf + nblocks * 16, src_size % 16);      FXSYS_memset(padding + src_size % 16, 16 - src_size % 16,                   16 - src_size % 16);      CRYPT_AESEncrypt(m_pAESContext, dest_buf + nblocks * 16 + 16, padding,                       16);      dest_size = 32 + nblocks * 16;    } else {      CRYPT_AESSetIV(m_pAESContext, src_buf);      CRYPT_AESDecrypt(m_pAESContext, dest_buf, src_buf + 16, src_size - 16);      dest_size = src_size - 16;      dest_size -= dest_buf[dest_size - 1];    }  } else {    ASSERT(dest_size == src_size);    if (dest_buf != src_buf) {      FXSYS_memcpy(dest_buf, src_buf, src_size);    }    CRYPT_ArcFourCryptBlock(dest_buf, dest_size, realkey, realkeylen);  }}

FX_STRSIZE CFX_WideString::Replace(const FX_WCHAR* lpszOld, const FX_WCHAR* lpszNew){    if (GetLength() < 1) {        return 0;    }    if (lpszOld == NULL) {        return 0;    }    FX_STRSIZE nSourceLen = FXSYS_wcslen(lpszOld);    if (nSourceLen == 0) {        return 0;    }    FX_STRSIZE nReplacementLen = lpszNew ? FXSYS_wcslen(lpszNew) : 0;    FX_STRSIZE nCount = 0;    FX_WCHAR* lpszStart = m_pData->m_String;    FX_WCHAR* lpszEnd = m_pData->m_String + m_pData->m_nDataLength;    FX_WCHAR* lpszTarget;    {        while ((lpszTarget = (FX_WCHAR*)FXSYS_wcsstr(lpszStart, lpszOld)) != NULL && lpszStart < lpszEnd) {            nCount++;            lpszStart = lpszTarget + nSourceLen;        }    }    if (nCount > 0) {        CopyBeforeWrite();        FX_STRSIZE nOldLength = m_pData->m_nDataLength;        FX_STRSIZE nNewLength =  nOldLength + (nReplacementLen - nSourceLen) * nCount;        if (m_pData->m_nAllocLength < nNewLength || m_pData->m_nRefs > 1) {            StringData* pOldData = m_pData;            const FX_WCHAR* pstr = m_pData->m_String;            m_pData = StringData::Create(nNewLength);            if (!m_pData) {                return 0;            }            FXSYS_memcpy(m_pData->m_String, pstr, pOldData->m_nDataLength * sizeof(FX_WCHAR));            pOldData->Release();        }        lpszStart = m_pData->m_String;        lpszEnd = m_pData->m_String + FX_MAX(m_pData->m_nDataLength, nNewLength);        {            while ((lpszTarget = (FX_WCHAR*)FXSYS_wcsstr(lpszStart, lpszOld)) != NULL && lpszStart < lpszEnd) {                FX_STRSIZE nBalance = nOldLength - (FX_STRSIZE)(lpszTarget - m_pData->m_String + nSourceLen);                FXSYS_memmove(lpszTarget + nReplacementLen, lpszTarget + nSourceLen, nBalance * sizeof(FX_WCHAR));                FXSYS_memcpy(lpszTarget, lpszNew, nReplacementLen * sizeof(FX_WCHAR));                lpszStart = lpszTarget + nReplacementLen;                lpszStart[nBalance] = 0;                nOldLength += (nReplacementLen - nSourceLen);            }        }        ASSERT(m_pData->m_String[nNewLength] == 0);        m_pData->m_nDataLength = nNewLength;    }    return nCount;}

CFX_WideString::CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2){    m_pData = NULL;    int nNewLen = str1.GetLength() + str2.GetLength();    if (nNewLen == 0) {        return;    }    m_pData = StringData::Create(nNewLen);    if (m_pData) {        FXSYS_memcpy(m_pData->m_String, str1.GetPtr(), str1.GetLength()*sizeof(FX_WCHAR));        FXSYS_memcpy(m_pData->m_String + str1.GetLength(), str2.GetPtr(), str2.GetLength()*sizeof(FX_WCHAR));    }}

void CFDE_TxtEdtBuf::Insert(int32_t nPos,                            const FX_WCHAR* lpText,                            int32_t nLength) {  ASSERT(nPos >= 0 && nPos <= m_nTotal);  FDE_CHUNKPLACE cp;  Index2CP(nPos, cp);  int32_t nLengthTemp = nLength;  if (cp.nCharIndex != 0) {    FDE_CHUNKHEADER* lpNewChunk =        static_cast<FDE_CHUNKHEADER*>(m_pAllocator->Alloc(            sizeof(FDE_CHUNKHEADER) + (m_nChunkSize - 1) * sizeof(FX_WCHAR)));    FDE_CHUNKHEADER* lpChunk = m_Chunks[cp.nChunkIndex];    int32_t nCopy = lpChunk->nUsed - cp.nCharIndex;    FXSYS_memcpy(lpNewChunk->wChars, lpChunk->wChars + cp.nCharIndex,                 nCopy * sizeof(FX_WCHAR));    lpChunk->nUsed -= nCopy;    cp.nChunkIndex++;    m_Chunks.InsertAt(cp.nChunkIndex, lpNewChunk);    lpNewChunk->nUsed = nCopy;    cp.nCharIndex = 0;  }  if (cp.nChunkIndex != 0) {    FDE_CHUNKHEADER* lpChunk = m_Chunks[cp.nChunkIndex - 1];    if (lpChunk->nUsed != m_nChunkSize) {      cp.nChunkIndex--;      int32_t nFree = m_nChunkSize - lpChunk->nUsed;      int32_t nCopy = std::min(nLengthTemp, nFree);      FXSYS_memcpy(lpChunk->wChars + lpChunk->nUsed, lpText,                   nCopy * sizeof(FX_WCHAR));      lpText += nCopy;      nLengthTemp -= nCopy;      lpChunk->nUsed += nCopy;      cp.nChunkIndex++;    }  }  while (nLengthTemp > 0) {    FDE_CHUNKHEADER* lpChunk =        static_cast<FDE_CHUNKHEADER*>(m_pAllocator->Alloc(            sizeof(FDE_CHUNKHEADER) + (m_nChunkSize - 1) * sizeof(FX_WCHAR)));    ASSERT(lpChunk);    int32_t nCopy = std::min(nLengthTemp, m_nChunkSize);    FXSYS_memcpy(lpChunk->wChars, lpText, nCopy * sizeof(FX_WCHAR));    lpText += nCopy;    nLengthTemp -= nCopy;    lpChunk->nUsed = nCopy;    m_Chunks.InsertAt(cp.nChunkIndex, lpChunk);    cp.nChunkIndex++;  }  m_nTotal += nLength;  m_bChanged = TRUE;}

static void _CompactStringStore(_CompactString* pCompact,                                const uint8_t* pStr,                                int len) {  if (len < (int)sizeof(_CompactString)) {    pCompact->m_CompactLen = (uint8_t)len;    FXSYS_memcpy(&pCompact->m_LenHigh, pStr, len);    return;  }  pCompact->m_CompactLen = 0xff;  pCompact->m_LenHigh = len / 256;  pCompact->m_LenLow = len % 256;  pCompact->m_pBuffer = FX_Alloc(uint8_t, len);  FXSYS_memcpy(pCompact->m_pBuffer, pStr, len);}

FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(    const uint8_t* password,    FX_DWORD pass_size,    FX_BOOL bIgnoreEncryptMeta,    uint8_t* key,    int32_t key_len) {  CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len,                 bIgnoreEncryptMeta, m_pParser->GetIDArray());  CFX_ByteString ukey = m_pEncryptDict                            ? m_pEncryptDict->GetString(FX_BSTRC("U"))                            : CFX_ByteString();  if (ukey.GetLength() < 16) {    return FALSE;  }  uint8_t ukeybuf[32];  if (m_Revision == 2) {    FXSYS_memcpy(ukeybuf, defpasscode, 32);    CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);  } else {    uint8_t test[32], tmpkey[32];    FX_DWORD copy_len = sizeof(test);    if (copy_len > (FX_DWORD)ukey.GetLength()) {      copy_len = ukey.GetLength();    }    FXSYS_memset(test, 0, sizeof(test));    FXSYS_memset(tmpkey, 0, sizeof(tmpkey));    FXSYS_memcpy(test, ukey.c_str(), copy_len);    for (int i = 19; i >= 0; i--) {      for (int j = 0; j < key_len; j++) {        tmpkey[j] = key[j] ^ i;      }      CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);    }    uint8_t md5[100];    CRYPT_MD5Start(md5);    CRYPT_MD5Update(md5, defpasscode, 32);    CPDF_Array* pIdArray = m_pParser->GetIDArray();    if (pIdArray) {      CFX_ByteString id = pIdArray->GetString(0);      CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());    }    CRYPT_MD5Finish(md5, ukeybuf);    return FXSYS_memcmp(test, ukeybuf, 16) == 0;  }  if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {    return TRUE;  }  return FALSE;}

CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(    const uint8_t* owner_pass,    FX_DWORD pass_size,    int32_t key_len) {  CFX_ByteString okey = m_pEncryptDict->GetString(FX_BSTRC("O"));  uint8_t passcode[32];  FX_DWORD i;  for (i = 0; i < 32; i++) {    passcode[i] = i < pass_size ? owner_pass[i] : defpasscode[i - pass_size];  }  uint8_t digest[16];  CRYPT_MD5Generate(passcode, 32, digest);  if (m_Revision >= 3) {    for (int i = 0; i < 50; i++) {      CRYPT_MD5Generate(digest, 16, digest);    }  }  uint8_t enckey[32];  FXSYS_memset(enckey, 0, sizeof(enckey));  FX_DWORD copy_len = key_len;  if (copy_len > sizeof(digest)) {    copy_len = sizeof(digest);  }  FXSYS_memcpy(enckey, digest, copy_len);  int okeylen = okey.GetLength();  if (okeylen > 32) {    okeylen = 32;  }  uint8_t okeybuf[64];  FXSYS_memset(okeybuf, 0, sizeof(okeybuf));  FXSYS_memcpy(okeybuf, okey.c_str(), okeylen);  if (m_Revision == 2) {    CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);  } else {    for (int i = 19; i >= 0; i--) {      uint8_t tempkey[32];      FXSYS_memset(tempkey, 0, sizeof(tempkey));      for (int j = 0; j < m_KeyLen; j++) {        tempkey[j] = enckey[j] ^ i;      }      CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len);    }  }  int len = 32;  while (len && defpasscode[len - 1] == okeybuf[len - 1]) {    len--;  }  return CFX_ByteString(okeybuf, len);}

FX_BOOL CFX_BasicArray::Copy(const CFX_BasicArray& src) {  if (!SetSize(src.m_nSize)) {    return FALSE;  }  FXSYS_memcpy(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);  return TRUE;}

void CFDE_TxtEdtBuf::GetRange(CFX_WideString& wsText,                              int32_t nBegin,                              int32_t nLength) const {  FDE_CHUNKPLACE cp;  Index2CP(nBegin, cp);  int32_t nLeave = nLength;  int32_t nCount = m_Chunks.GetSize();  FX_WCHAR* lpDstBuf = wsText.GetBuffer(nLength);  int32_t nChunkIndex = cp.nChunkIndex;  FDE_CHUNKHEADER* lpChunkHeader = m_Chunks[nChunkIndex];  int32_t nCopyLength = lpChunkHeader->nUsed - cp.nCharIndex;  FX_WCHAR* lpSrcBuf = lpChunkHeader->wChars + cp.nCharIndex;  while (nLeave > 0) {    if (nLeave <= nCopyLength) {      nCopyLength = nLeave;    }    FXSYS_memcpy(lpDstBuf, lpSrcBuf, nCopyLength * sizeof(FX_WCHAR));    nChunkIndex++;    if (nChunkIndex >= nCount) {      break;    }    lpChunkHeader = m_Chunks[nChunkIndex];    lpSrcBuf = lpChunkHeader->wChars;    nLeave -= nCopyLength;    lpDstBuf += nCopyLength;    nCopyLength = lpChunkHeader->nUsed;  }  wsText.ReleaseBuffer();}

void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, FX_BOOL bCompressed, FX_BOOL bKeepBuf){    if (m_GenNum == (FX_DWORD) - 1) {        if (m_pDataBuf) {            FX_Free(m_pDataBuf);        }    } else {        m_GenNum = (FX_DWORD) - 1;        m_pCryptoHandler = NULL;    }    if (bKeepBuf) {        m_pDataBuf = (uint8_t*)pData;    } else {        m_pDataBuf = FX_Alloc(uint8_t, size);        if (pData) {            FXSYS_memcpy(m_pDataBuf, pData, size);        }    }    m_dwSize = size;    if (m_pDict == NULL) {        m_pDict = new CPDF_Dictionary;    }    m_pDict->SetAtInteger(FX_BSTRC("Length"), size);    if (!bCompressed) {        m_pDict->RemoveAt(FX_BSTRC("Filter"));        m_pDict->RemoveAt(FX_BSTRC("DecodeParms"));    }}

FX_BOOL CXFA_FileRead::ReadBlock(void* buffer,                                 FX_FILESIZE offset,                                 size_t size) {  int32_t iCount = m_Data.GetSize();  int32_t index = 0;  while (index < iCount) {    CPDF_StreamAcc& acc = m_Data[index];    FX_FILESIZE dwSize = acc.GetSize();    if (offset < dwSize) {      break;    }    offset -= dwSize;    index++;  }  while (index < iCount) {    CPDF_StreamAcc& acc = m_Data[index];    uint32_t dwSize = acc.GetSize();    size_t dwRead = std::min(size, static_cast<size_t>(dwSize - offset));    FXSYS_memcpy(buffer, acc.GetData() + offset, dwRead);    size -= dwRead;    if (size == 0) {      return TRUE;    }    buffer = (uint8_t*)buffer + dwRead;    offset = 0;    index++;  }  return FALSE;}

DLLEXPORT FPDF_BOOL STDCALLFPDF_StringHandleGetStringByIndex(FPDF_STRINGHANDLE sHandle,                                  int index,                                  FPDF_BYTESTRING bsText,                                  FPDF_DWORD* size) {  if (!sHandle || !size)    return FALSE;  int count = FPDF_StringHandleCounts(sHandle);  if (index < 0 || index >= count)    return FALSE;  std::vector<CFX_ByteString>* sSuggestWords = FromFPDFStringHandle(sHandle);  int len = (*sSuggestWords)[index].GetLength();  if (!bsText) {    *size = len;    return TRUE;  }  int real_size = len < *size ? len : *size;  if (real_size > 0)    FXSYS_memcpy((void*)bsText, (const FX_CHAR*)(*sSuggestWords)[index],                 real_size);  *size = real_size;  return TRUE;}

bool CFX_BasicArray::Copy(const CFX_BasicArray& src) {  if (!SetSize(src.m_nSize)) {    return false;  }  FXSYS_memcpy(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);  return true;}

DLLEXPORT int STDCALL FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page,                                              double left,                                              double top,                                              double right,                                              double bottom,                                              unsigned short* buffer,                                              int buflen) {  if (!text_page)    return 0;  CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);  CFX_FloatRect rect((FX_FLOAT)left, (FX_FLOAT)bottom, (FX_FLOAT)right,                     (FX_FLOAT)top);  CFX_WideString str = textpage->GetTextByRect(rect);  if (buflen <= 0 || !buffer)    return str.GetLength();  CFX_ByteString cbUTF16Str = str.UTF16LE_Encode();  int len = cbUTF16Str.GetLength() / sizeof(unsigned short);  int size = buflen > len ? len : buflen;  FXSYS_memcpy(buffer, cbUTF16Str.GetBuffer(size * sizeof(unsigned short)),               size * sizeof(unsigned short));  cbUTF16Str.ReleaseBuffer(size * sizeof(unsigned short));  return size;}

DLLEXPORT void STDCALL FPDF_Widget_Cut(FPDF_DOCUMENT document,                                       FPDF_WIDGET hWidget,                                       FPDF_WIDESTRING wsText,                                       FPDF_DWORD* size) {  if (NULL == hWidget || NULL == document)    return;  CPDFXFA_Document* pDocument = (CPDFXFA_Document*)document;  if (pDocument->GetDocType() != XFA_DOCTYPE_Dynamic &&      pDocument->GetDocType() != XFA_DOCTYPE_Static)    return;  IXFA_MenuHandler* pXFAMenuHander =      CPDFXFA_App::GetInstance()->GetXFAApp()->GetMenuHandler();  if (pXFAMenuHander == NULL)    return;  CFX_WideString wsCpText;  pXFAMenuHander->Cut((IXFA_Widget*)hWidget, wsCpText);  CFX_ByteString bsCpText = wsCpText.UTF16LE_Encode();  int len = bsCpText.GetLength() / sizeof(unsigned short);  if (wsText == NULL) {    *size = len;    return;  }  int real_size = len < *size ? len : *size;  if (real_size > 0) {    FXSYS_memcpy((void*)wsText,                 bsCpText.GetBuffer(real_size * sizeof(unsigned short)),                 real_size * sizeof(unsigned short));    bsCpText.ReleaseBuffer(real_size * sizeof(unsigned short));  }  *size = real_size;}

CFDE_CSSValueList::CFDE_CSSValueList(IFX_MEMAllocator* pStaticStore,                                     const CFDE_CSSValueArray& list) {  m_iCount = list.GetSize();  int32_t iByteCount = m_iCount * sizeof(IFDE_CSSValue*);  m_ppList = (IFDE_CSSValue**)pStaticStore->Alloc(iByteCount);  FXSYS_memcpy(m_ppList, list.GetData(), iByteCount);}

void CFX_WideString::AssignCopy(FX_STRSIZE nSrcLen, const FX_WCHAR* lpszSrcData){    AllocBeforeWrite(nSrcLen);    FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));    m_pData->m_nDataLength = nSrcLen;    m_pData->m_String[nSrcLen] = 0;}

bool CPDF_CryptoHandler::Init(int cipher, const uint8_t* key, int keylen) {  if (cipher == FXCIPHER_AES) {    switch (keylen) {      case 16:      case 24:      case 32:        break;      default:        return false;    }  } else if (cipher == FXCIPHER_AES2) {    if (keylen != 32) {      return false;    }  } else if (cipher == FXCIPHER_RC4) {    if (keylen < 5 || keylen > 16) {      return false;    }  } else {    if (keylen > 32) {      keylen = 32;    }  }  m_Cipher = cipher;  m_KeyLen = keylen;  FXSYS_memcpy(m_EncryptKey, key, keylen);  if (m_Cipher == FXCIPHER_AES) {    m_pAESContext = FX_Alloc(uint8_t, 2048);  }  return true;}

FX_BOOL CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString,                                            const FX_WCHAR* lpszFullString,                                            int iSubString,                                            FX_WCHAR chSep) {  if (!lpszFullString)    return FALSE;  while (iSubString--) {    lpszFullString = std::wcschr(lpszFullString, chSep);    if (!lpszFullString) {      rString.clear();      return FALSE;    }    lpszFullString++;    while (*lpszFullString == chSep)      lpszFullString++;  }  const FX_WCHAR* lpchEnd = std::wcschr(lpszFullString, chSep);  int nLen = lpchEnd ? (int)(lpchEnd - lpszFullString)                     : (int)FXSYS_wcslen(lpszFullString);  ASSERT(nLen >= 0);  FXSYS_memcpy(rString.GetBuffer(nLen), lpszFullString,               nLen * sizeof(FX_WCHAR));  rString.ReleaseBuffer();  return TRUE;}

void CPDF_Color::Copy(const CPDF_Color* pSrc) {  ReleaseBuffer();  ReleaseColorSpace();  m_pCS = pSrc->m_pCS;  if (m_pCS && m_pCS->m_pDocument) {    CPDF_Array* pArray = m_pCS->GetArray();    if (pArray) {      m_pCS = m_pCS->m_pDocument->GetPageData()->GetCopiedColorSpace(pArray);    }  }  if (m_pCS == NULL) {    return;  }  m_pBuffer = m_pCS->CreateBuf();  FXSYS_memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());  if (m_pCS->GetFamily() == PDFCS_PATTERN) {    PatternValue* pvalue = (PatternValue*)m_pBuffer;    if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {      pvalue->m_pPattern =          pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(              pvalue->m_pPattern->m_pPatternObj, FALSE,              &pvalue->m_pPattern->m_ParentMatrix);    }  }}

FX_DWORD _DecodeAllScanlines(ICodec_ScanlineDecoder* pDecoder, uint8_t*& dest_buf, FX_DWORD& dest_size){    if (pDecoder == NULL) {        return (FX_DWORD) - 1;    }    int ncomps = pDecoder->CountComps();    int bpc = pDecoder->GetBPC();    int width = pDecoder->GetWidth();    int height = pDecoder->GetHeight();    int pitch = (width * ncomps * bpc + 7) / 8;    if (height == 0 || pitch > (1 << 30) / height) {        delete pDecoder;        return -1;    }    dest_buf = FX_Alloc2D(uint8_t, pitch, height);    dest_size = pitch * height;  // Safe since checked alloc returned.    for (int row = 0; row < height; row ++) {        uint8_t* pLine = pDecoder->GetScanline(row);        if (pLine == NULL) {            break;        }        FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);    }    FX_DWORD srcoff = pDecoder->GetSrcOffset();    delete pDecoder;    return srcoff;}

void CPDF_Color::SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comps, int ncomps){    if (ncomps > MAX_PATTERN_COLORCOMPS) {        return;    }    if (m_pCS == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {        if (m_pBuffer) {            FX_Free(m_pBuffer);        }        m_pCS = CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);        m_pBuffer = m_pCS->CreateBuf();    }    CPDF_DocPageData *pDocPageData = NULL;    PatternValue* pvalue = (PatternValue*)m_pBuffer;    if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {        pDocPageData = pvalue->m_pPattern->m_pDocument->GetPageData();        if (pDocPageData) {            pDocPageData->ReleasePattern(pvalue->m_pPattern->m_pPatternObj);        }    }    pvalue->m_nComps = ncomps;    pvalue->m_pPattern = pPattern;    if (ncomps) {        FXSYS_memcpy(pvalue->m_Comps, comps, ncomps * sizeof(FX_FLOAT));    }    pvalue->m_pCountedPattern = NULL;    if (pPattern && pPattern->m_pDocument)    {        if (!pDocPageData) {            pDocPageData = pPattern->m_pDocument->GetPageData();        }        pvalue->m_pCountedPattern = pDocPageData->FindPatternPtr(pPattern->m_pPatternObj);    }}

void CPDF_Stream::SetData(const uint8_t* pData,                          uint32_t size,                          FX_BOOL bCompressed,                          FX_BOOL bKeepBuf) {  if (IsMemoryBased())    FX_Free(m_pDataBuf);  m_GenNum = kMemoryBasedGenNum;  if (bKeepBuf) {    m_pDataBuf = const_cast<uint8_t*>(pData);  } else {    m_pDataBuf = FX_Alloc(uint8_t, size);    if (pData) {      FXSYS_memcpy(m_pDataBuf, pData, size);    }  }  m_dwSize = size;  if (!m_pDict)    m_pDict = new CPDF_Dictionary;  m_pDict->SetAtInteger("Length", size);  if (!bCompressed) {    m_pDict->RemoveAt("Filter");    m_pDict->RemoveAt("DecodeParms");  }}

bool CPDF_CryptoHandler::CryptStream(void* context,                                     const uint8_t* src_buf,                                     uint32_t src_size,                                     CFX_BinaryBuf& dest_buf,                                     bool bEncrypt) {  if (!context) {    return false;  }  if (m_Cipher == FXCIPHER_NONE) {    dest_buf.AppendBlock(src_buf, src_size);    return true;  }  if (m_Cipher == FXCIPHER_RC4) {    int old_size = dest_buf.GetSize();    dest_buf.AppendBlock(src_buf, src_size);    CRYPT_ArcFourCrypt(reinterpret_cast<CRYPT_rc4_context*>(context),                       dest_buf.GetBuffer() + old_size, src_size);    return true;  }  AESCryptContext* pContext = reinterpret_cast<AESCryptContext*>(context);  if (pContext->m_bIV && bEncrypt) {    dest_buf.AppendBlock(pContext->m_Block, 16);    pContext->m_bIV = false;  }  uint32_t src_off = 0;  uint32_t src_left = src_size;  while (1) {    uint32_t copy_size = 16 - pContext->m_BlockOffset;    if (copy_size > src_left) {      copy_size = src_left;    }    FXSYS_memcpy(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off,                 copy_size);    src_off += copy_size;    src_left -= copy_size;    pContext->m_BlockOffset += copy_size;    if (pContext->m_BlockOffset == 16) {      if (!bEncrypt && pContext->m_bIV) {        CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);        pContext->m_bIV = false;        pContext->m_BlockOffset = 0;      } else if (src_off < src_size) {        uint8_t block_buf[16];        if (bEncrypt) {          CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block,                           16);        } else {          CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block,                           16);        }        dest_buf.AppendBlock(block_buf, 16);        pContext->m_BlockOffset = 0;      }    }    if (!src_left) {      break;    }  }  return true;}

void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size) {  ExpandBuf(size);  if (pBuf && m_pBuffer) {    FXSYS_memcpy(m_pBuffer + m_DataSize, pBuf, size);  }  m_DataSize += size;}

int32_t CFDE_TxtEdtPage::GetDisplayPos(const CFX_RectF& rtClip,                                       FXTEXT_CHARPOS*& pCharPos,                                       CFX_RectF* pBBox) const {    pCharPos = FX_Alloc(FXTEXT_CHARPOS, m_nCharCount);    int32_t nCharPosCount = 0;    FDE_TEXTEDITPIECE* pPiece = nullptr;    int32_t nVisualObjCount = m_PieceMassArr.GetSize();    FXTEXT_CHARPOS* pos = pCharPos;    CFX_RectF rtObj;    for (int32_t i = 0; i < nVisualObjCount; i++) {        pPiece = m_PieceMassArr.GetPtrAt(i);        m_pTextSet->GetRect(pPiece, rtObj);        if (!rtClip.IntersectWith(rtObj)) {            continue;        }        int32_t nCount = m_pTextSet->GetDisplayPos(pPiece, pos, FALSE);        nCharPosCount += nCount;        pos += nCount;    }    if ((nCharPosCount * 5) < (m_nCharCount << 2)) {        FXTEXT_CHARPOS* pTemp = FX_Alloc(FXTEXT_CHARPOS, nCharPosCount);        FXSYS_memcpy(pTemp, pCharPos, sizeof(FXTEXT_CHARPOS) * nCharPosCount);        FX_Free(pCharPos);        pCharPos = pTemp;    }    return nCharPosCount;}