From 1c5d0b48ec7a6443ba72fec2a58a65fc6d694aca Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Mon, 3 Apr 2017 15:05:11 -0400 Subject: Drop FXSYS_ from mem methods This Cl drops the FXSYS_ from mem methods which are the same on all platforms. Bug: pdfium:694 Change-Id: I9d5ae905997dbaaec5aa0b2ae4c07358ed9c6236 Reviewed-on: https://pdfium-review.googlesource.com/3613 Reviewed-by: Tom Sepez Commit-Queue: dsinclair --- core/fdrm/crypto/fx_crypt.cpp | 4 +- core/fdrm/crypto/fx_crypt_aes.cpp | 8 +-- core/fdrm/crypto/fx_crypt_sha.cpp | 24 ++++----- core/fpdfapi/edit/fpdf_edit_create.cpp | 6 +-- core/fpdfapi/font/cpdf_fontencoding.cpp | 7 ++- core/fpdfapi/font/cpdf_simplefont.cpp | 6 +-- core/fpdfapi/font/cpdf_type1font.cpp | 12 ++--- core/fpdfapi/font/cpdf_type3font.cpp | 2 +- core/fpdfapi/font/fpdf_font.cpp | 4 +- core/fpdfapi/font/fpdf_font_cid.cpp | 10 ++-- core/fpdfapi/page/cpdf_color.cpp | 6 +-- core/fpdfapi/page/cpdf_contentparser.cpp | 2 +- core/fpdfapi/page/cpdf_image.cpp | 6 +-- core/fpdfapi/page/cpdf_meshstream.cpp | 2 +- core/fpdfapi/page/cpdf_streamcontentparser.cpp | 4 +- core/fpdfapi/page/cpdf_streamparser.cpp | 6 +-- core/fpdfapi/page/fpdf_page_colors.cpp | 3 +- core/fpdfapi/page/fpdf_page_func.cpp | 4 +- core/fpdfapi/parser/cpdf_crypto_handler.cpp | 31 ++++++------ core/fpdfapi/parser/cpdf_document.cpp | 2 +- core/fpdfapi/parser/cpdf_object_unittest.cpp | 4 +- core/fpdfapi/parser/cpdf_parser.cpp | 2 +- core/fpdfapi/parser/cpdf_security_handler.cpp | 46 +++++++++--------- core/fpdfapi/parser/cpdf_stream.cpp | 6 +-- core/fpdfapi/parser/cpdf_stream_acc.cpp | 2 +- core/fpdfapi/parser/cpdf_syntax_parser.cpp | 11 ++--- core/fpdfapi/parser/fpdf_parser_decode.cpp | 8 +-- core/fpdfapi/render/cpdf_dibsource.cpp | 10 ++-- core/fpdfapi/render/cpdf_docrenderdata.cpp | 2 +- core/fpdfapi/render/cpdf_renderstatus.cpp | 18 +++---- core/fpdftext/cpdf_textpagefind.cpp | 2 +- core/fxcodec/codec/ccodec_bmpmodule.cpp | 2 +- core/fxcodec/codec/ccodec_gifmodule.cpp | 4 +- core/fxcodec/codec/ccodec_pngmodule.cpp | 10 ++-- core/fxcodec/codec/ccodec_tiffmodule.cpp | 8 +-- core/fxcodec/codec/fx_codec.cpp | 10 ++-- core/fxcodec/codec/fx_codec_fax.cpp | 16 +++--- core/fxcodec/codec/fx_codec_flate.cpp | 25 +++++----- core/fxcodec/codec/fx_codec_jbig.cpp | 2 +- core/fxcodec/codec/fx_codec_jpeg.cpp | 9 ++-- core/fxcodec/codec/fx_codec_jpx_opj.cpp | 8 +-- core/fxcodec/codec/fx_codec_progress.cpp | 44 ++++++++--------- core/fxcodec/jbig2/JBig2_Define.h | 6 +-- core/fxcodec/lbmp/fx_bmp.cpp | 41 ++++++++-------- core/fxcodec/lgif/fx_gif.cpp | 67 ++++++++++++-------------- core/fxcrt/cfx_bytestring.cpp | 32 ++++++------ core/fxcrt/cfx_checksumcontext.cpp | 2 +- core/fxcrt/cfx_string_data_template.h | 8 +-- core/fxcrt/cfx_widestring.cpp | 4 +- core/fxcrt/fx_basic.h | 2 +- core/fxcrt/fx_basic_buffer.cpp | 19 ++++---- core/fxcrt/fx_extension.cpp | 10 ++-- core/fxcrt/fx_system.h | 4 -- core/fxcrt/fxcrt_posix.cpp | 2 +- core/fxcrt/xml/cfx_saxreader.cpp | 9 ++-- core/fxge/android/cfpf_skiafontdescriptor.h | 2 +- core/fxge/android/cfpf_skiafontmgr.cpp | 2 +- core/fxge/android/cfpf_skiapathfont.h | 2 +- core/fxge/dib/cfx_bitmapcomposer.cpp | 2 +- core/fxge/dib/cfx_bitmapstorer.cpp | 6 +-- core/fxge/dib/cfx_dibitmap.cpp | 43 ++++++++--------- core/fxge/dib/cfx_dibsource.cpp | 22 ++++----- core/fxge/dib/cfx_scanlinecompositor.cpp | 6 +-- core/fxge/dib/fx_dib_convert.cpp | 16 +++--- core/fxge/dib/fx_dib_engine.cpp | 2 +- core/fxge/ge/cfx_facecache.cpp | 10 ++-- core/fxge/ge/cfx_fontmapper.cpp | 2 +- core/fxge/ge/cfx_graphstatedata.cpp | 2 +- core/fxge/skia/fx_skia_device.cpp | 4 +- core/fxge/win32/cfx_psrenderer.cpp | 8 +-- core/fxge/win32/cpsoutput.cpp | 2 +- core/fxge/win32/fx_win32_device.cpp | 6 +-- core/fxge/win32/fx_win32_dib.cpp | 14 +++--- core/fxge/win32/fx_win32_gdipext.cpp | 8 +-- 74 files changed, 373 insertions(+), 390 deletions(-) (limited to 'core') diff --git a/core/fdrm/crypto/fx_crypt.cpp b/core/fdrm/crypto/fx_crypt.cpp index 4010ff49ee..d1a1aae471 100644 --- a/core/fdrm/crypto/fx_crypt.cpp +++ b/core/fdrm/crypto/fx_crypt.cpp @@ -204,7 +204,7 @@ void CRYPT_MD5Update(CRYPT_md5_context* ctx, ctx->total[0] &= 0xFFFFFFFF; ctx->total[1] += ctx->total[0] < length << 3; if (left && length >= fill) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, fill); + memcpy((void*)(ctx->buffer + left), (void*)input, fill); md5_process(ctx, ctx->buffer); length -= fill; input += fill; @@ -216,7 +216,7 @@ void CRYPT_MD5Update(CRYPT_md5_context* ctx, input += 64; } if (length) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length); + memcpy((void*)(ctx->buffer + left), (void*)input, length); } } diff --git a/core/fdrm/crypto/fx_crypt_aes.cpp b/core/fdrm/crypto/fx_crypt_aes.cpp index 8484b6f4a5..e900dbd3e4 100644 --- a/core/fdrm/crypto/fx_crypt_aes.cpp +++ b/core/fdrm/crypto/fx_crypt_aes.cpp @@ -762,7 +762,7 @@ static void aes_decrypt_cbc(unsigned char* dest, unsigned int iv[4], x[4], ct[4]; int i; ASSERT((len & 15) == 0); - FXSYS_memcpy(iv, ctx->iv, sizeof(iv)); + memcpy(iv, ctx->iv, sizeof(iv)); while (len > 0) { for (i = 0; i < 4; i++) { x[i] = ct[i] = GET_32BIT_MSB_FIRST(src + 4 * i); @@ -776,7 +776,7 @@ static void aes_decrypt_cbc(unsigned char* dest, src += 16; len -= 16; } - FXSYS_memcpy(ctx->iv, iv, sizeof(iv)); + memcpy(ctx->iv, iv, sizeof(iv)); } static void aes_encrypt(AESContext* ctx, unsigned int* block) { ctx->encrypt(ctx, block); @@ -788,7 +788,7 @@ static void aes_encrypt_cbc(unsigned char* dest, unsigned int iv[4]; int i; ASSERT((len & 15) == 0); - FXSYS_memcpy(iv, ctx->iv, sizeof(iv)); + memcpy(iv, ctx->iv, sizeof(iv)); while (len > 0) { for (i = 0; i < 4; i++) { iv[i] ^= GET_32BIT_MSB_FIRST(src + 4 * i); @@ -801,7 +801,7 @@ static void aes_encrypt_cbc(unsigned char* dest, src += 16; len -= 16; } - FXSYS_memcpy(ctx->iv, iv, sizeof(iv)); + memcpy(ctx->iv, iv, sizeof(iv)); } void CRYPT_AESSetKey(void* context, uint32_t blocklen, diff --git a/core/fdrm/crypto/fx_crypt_sha.cpp b/core/fdrm/crypto/fx_crypt_sha.cpp index 51f9588e04..f79b831277 100644 --- a/core/fdrm/crypto/fx_crypt_sha.cpp +++ b/core/fdrm/crypto/fx_crypt_sha.cpp @@ -90,11 +90,11 @@ void CRYPT_SHA1Update(CRYPT_sha1_context* s, s->lenlo += lenw; s->lenhi += (s->lenlo < lenw); if (s->blkused && s->blkused + len < 64) { - FXSYS_memcpy(s->block + s->blkused, q, len); + memcpy(s->block + s->blkused, q, len); s->blkused += len; } else { while (s->blkused + len >= 64) { - FXSYS_memcpy(s->block + s->blkused, q, 64 - s->blkused); + memcpy(s->block + s->blkused, q, 64 - s->blkused); q += 64 - s->blkused; len -= 64 - s->blkused; for (i = 0; i < 16; i++) { @@ -106,7 +106,7 @@ void CRYPT_SHA1Update(CRYPT_sha1_context* s, SHATransform(s->h, wordblock); s->blkused = 0; } - FXSYS_memcpy(s->block, q, len); + memcpy(s->block, q, len); s->blkused = len; } } @@ -123,7 +123,7 @@ void CRYPT_SHA1Finish(CRYPT_sha1_context* s, uint8_t digest[20]) { } lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3)); lenlo = (s->lenlo << 3); - FXSYS_memset(c, 0, pad); + memset(c, 0, pad); c[0] = 0x80; CRYPT_SHA1Update(s, c, pad); c[0] = (lenhi >> 24) & 0xFF; @@ -307,7 +307,7 @@ void CRYPT_SHA256Update(CRYPT_sha256_context* ctx, ctx->total[1]++; } if (left && length >= fill) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, fill); + memcpy((void*)(ctx->buffer + left), (void*)input, fill); sha256_process(ctx, ctx->buffer); length -= fill; input += fill; @@ -319,7 +319,7 @@ void CRYPT_SHA256Update(CRYPT_sha256_context* ctx, input += 64; } if (length) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length); + memcpy((void*)(ctx->buffer + left), (void*)input, length); } } @@ -385,7 +385,7 @@ void CRYPT_SHA384Start(CRYPT_sha384_context* ctx) { if (!ctx) return; - FXSYS_memset(ctx, 0, sizeof(CRYPT_sha384_context)); + memset(ctx, 0, sizeof(CRYPT_sha384_context)); ctx->state[0] = FX_ato64i("cbbb9d5dc1059ed8"); ctx->state[1] = FX_ato64i("629a292a367cd507"); ctx->state[2] = FX_ato64i("9159015a3070dd17"); @@ -556,7 +556,7 @@ void CRYPT_SHA384Update(CRYPT_sha384_context* ctx, ctx->total[1]++; } if (left && length >= fill) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, fill); + memcpy((void*)(ctx->buffer + left), (void*)input, fill); sha384_process(ctx, ctx->buffer); length -= fill; input += fill; @@ -568,14 +568,14 @@ void CRYPT_SHA384Update(CRYPT_sha384_context* ctx, input += 128; } if (length) { - FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length); + memcpy((void*)(ctx->buffer + left), (void*)input, length); } } void CRYPT_SHA384Finish(CRYPT_sha384_context* ctx, uint8_t digest[48]) { uint32_t last, padn; uint8_t msglen[16]; - FXSYS_memset(msglen, 0, 16); + memset(msglen, 0, 16); uint64_t high, low; high = (ctx->total[0] >> 29) | (ctx->total[1] << 3); low = (ctx->total[0] << 3); @@ -607,7 +607,7 @@ void CRYPT_SHA512Start(void* context) { return; } CRYPT_sha384_context* ctx = (CRYPT_sha384_context*)context; - FXSYS_memset(ctx, 0, sizeof(CRYPT_sha384_context)); + memset(ctx, 0, sizeof(CRYPT_sha384_context)); ctx->state[0] = FX_ato64i("6a09e667f3bcc908"); ctx->state[1] = FX_ato64i("bb67ae8584caa73b"); ctx->state[2] = FX_ato64i("3c6ef372fe94f82b"); @@ -627,7 +627,7 @@ void CRYPT_SHA512Finish(void* context, uint8_t digest[64]) { CRYPT_sha384_context* ctx = (CRYPT_sha384_context*)context; uint32_t last, padn; uint8_t msglen[16]; - FXSYS_memset(msglen, 0, 16); + memset(msglen, 0, 16); uint64_t high, low; high = (ctx->total[0] >> 29) | (ctx->total[1] << 3); low = (ctx->total[0] << 3); diff --git a/core/fpdfapi/edit/fpdf_edit_create.cpp b/core/fpdfapi/edit/fpdf_edit_create.cpp index e6fe6b4a59..59d3de35a9 100644 --- a/core/fpdfapi/edit/fpdf_edit_create.cpp +++ b/core/fpdfapi/edit/fpdf_edit_create.cpp @@ -778,7 +778,7 @@ bool CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, bool bEOF) { return false; } char offset_buf[20]; - FXSYS_memset(offset_buf, 0, sizeof(offset_buf)); + memset(offset_buf, 0, sizeof(offset_buf)); FXSYS_i64toa(m_PrevOffset, offset_buf, 10); int32_t offset_len = (int32_t)FXSYS_strlen(offset_buf); if (pFile->AppendBlock(offset_buf, offset_len) < 0) { @@ -1715,7 +1715,7 @@ int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause* pPause) { return -1; char offset_buf[20]; - FXSYS_memset(offset_buf, 0, sizeof(offset_buf)); + memset(offset_buf, 0, sizeof(offset_buf)); FXSYS_i64toa(prev, offset_buf, 10); if (m_File.AppendBlock(offset_buf, FXSYS_strlen(offset_buf)) < 0) return -1; @@ -1785,7 +1785,7 @@ int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause* pPause) { return -1; char offset_buf[20]; - FXSYS_memset(offset_buf, 0, sizeof(offset_buf)); + memset(offset_buf, 0, sizeof(offset_buf)); FXSYS_i64toa(m_XrefStart, offset_buf, 10); if (m_File.AppendBlock(offset_buf, FXSYS_strlen(offset_buf)) < 0) return -1; diff --git a/core/fpdfapi/font/cpdf_fontencoding.cpp b/core/fpdfapi/font/cpdf_fontencoding.cpp index be4eaff13b..2cc6445ab2 100644 --- a/core/fpdfapi/font/cpdf_fontencoding.cpp +++ b/core/fpdfapi/font/cpdf_fontencoding.cpp @@ -1646,7 +1646,7 @@ uint32_t PDF_FindCode(const uint16_t* pCodes, uint16_t unicode) { } // namespace CPDF_FontEncoding::CPDF_FontEncoding() { - FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes)); + memset(m_Unicodes, 0, sizeof(m_Unicodes)); } int CPDF_FontEncoding::CharCodeFromUnicode(wchar_t unicode) const { @@ -1660,7 +1660,7 @@ int CPDF_FontEncoding::CharCodeFromUnicode(wchar_t unicode) const { CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding) { const uint16_t* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding); if (!pSrc) { - FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes)); + memset(m_Unicodes, 0, sizeof(m_Unicodes)); } else { for (int i = 0; i < 256; i++) m_Unicodes[i] = pSrc[i]; @@ -1668,8 +1668,7 @@ CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding) { } bool CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const { - return FXSYS_memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) == - 0; + return memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) == 0; } std::unique_ptr CPDF_FontEncoding::Realize( diff --git a/core/fpdfapi/font/cpdf_simplefont.cpp b/core/fpdfapi/font/cpdf_simplefont.cpp index 94a690f221..a3597824bd 100644 --- a/core/fpdfapi/font/cpdf_simplefont.cpp +++ b/core/fpdfapi/font/cpdf_simplefont.cpp @@ -13,9 +13,9 @@ #include "third_party/base/numerics/safe_math.h" CPDF_SimpleFont::CPDF_SimpleFont() : m_BaseEncoding(PDFFONT_ENCODING_BUILTIN) { - FXSYS_memset(m_CharWidth, 0xff, sizeof(m_CharWidth)); - FXSYS_memset(m_GlyphIndex, 0xff, sizeof(m_GlyphIndex)); - FXSYS_memset(m_ExtGID, 0xff, sizeof(m_ExtGID)); + memset(m_CharWidth, 0xff, sizeof(m_CharWidth)); + memset(m_GlyphIndex, 0xff, sizeof(m_GlyphIndex)); + memset(m_ExtGID, 0xff, sizeof(m_ExtGID)); for (size_t i = 0; i < FX_ArraySize(m_CharBBox); ++i) m_CharBBox[i] = FX_RECT(-1, -1, -1, -1); } diff --git a/core/fpdfapi/font/cpdf_type1font.cpp b/core/fpdfapi/font/cpdf_type1font.cpp index a264a780c3..e3d96dad37 100644 --- a/core/fpdfapi/font/cpdf_type1font.cpp +++ b/core/fpdfapi/font/cpdf_type1font.cpp @@ -151,7 +151,7 @@ void CPDF_Type1Font::LoadGlyphMap() { if (bGotOne) { #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ if (!bCoreText) - FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256); + memcpy(m_ExtGID, m_GlyphIndex, 256); #endif return; } @@ -182,7 +182,7 @@ void CPDF_Type1Font::LoadGlyphMap() { } #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ if (!bCoreText) - FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256); + memcpy(m_ExtGID, m_GlyphIndex, 256); #endif return; } @@ -207,7 +207,7 @@ void CPDF_Type1Font::LoadGlyphMap() { FT_UnicodeFromCharCode(PDFFONT_ENCODING_STANDARD, charcode); } char name_glyph[256]; - FXSYS_memset(name_glyph, 0, sizeof(name_glyph)); + memset(name_glyph, 0, sizeof(name_glyph)); FXFT_Get_Glyph_Name(m_Font.GetFace(), m_GlyphIndex[charcode], name_glyph, 256); name_glyph[255] = 0; @@ -272,7 +272,7 @@ void CPDF_Type1Font::LoadGlyphMap() { FT_UnicodeFromCharCode(PDFFONT_ENCODING_STANDARD, charcode); if (unicode == 0) { char name_glyph[256]; - FXSYS_memset(name_glyph, 0, sizeof(name_glyph)); + memset(name_glyph, 0, sizeof(name_glyph)); FXFT_Get_Glyph_Name(m_Font.GetFace(), m_GlyphIndex[charcode], name_glyph, 256); name_glyph[255] = 0; @@ -286,7 +286,7 @@ void CPDF_Type1Font::LoadGlyphMap() { } #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ if (!bCoreText) - FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256); + memcpy(m_ExtGID, m_GlyphIndex, 256); #endif return; @@ -315,7 +315,7 @@ void CPDF_Type1Font::LoadGlyphMap() { } #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ if (!bCoreText) - FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256); + memcpy(m_ExtGID, m_GlyphIndex, 256); #endif } diff --git a/core/fpdfapi/font/cpdf_type3font.cpp b/core/fpdfapi/font/cpdf_type3font.cpp index 59702aed6a..da3b183c13 100644 --- a/core/fpdfapi/font/cpdf_type3font.cpp +++ b/core/fpdfapi/font/cpdf_type3font.cpp @@ -24,7 +24,7 @@ CPDF_Type3Font::CPDF_Type3Font() m_pPageResources(nullptr), m_pFontResources(nullptr), m_CharLoadingDepth(0) { - FXSYS_memset(m_CharWidthL, 0, sizeof(m_CharWidthL)); + memset(m_CharWidthL, 0, sizeof(m_CharWidthL)); } CPDF_Type3Font::~CPDF_Type3Font() {} diff --git a/core/fpdfapi/font/fpdf_font.cpp b/core/fpdfapi/font/fpdf_font.cpp index 706ae62cd9..23b46759d8 100644 --- a/core/fpdfapi/font/fpdf_font.cpp +++ b/core/fpdfapi/font/fpdf_font.cpp @@ -71,8 +71,8 @@ CPDF_Font* CFX_StockFontArray::SetFont(uint32_t index, } CPDF_FontGlobals::CPDF_FontGlobals() { - FXSYS_memset(m_EmbeddedCharsets, 0, sizeof(m_EmbeddedCharsets)); - FXSYS_memset(m_EmbeddedToUnicodes, 0, sizeof(m_EmbeddedToUnicodes)); + memset(m_EmbeddedCharsets, 0, sizeof(m_EmbeddedCharsets)); + memset(m_EmbeddedToUnicodes, 0, sizeof(m_EmbeddedToUnicodes)); } CPDF_FontGlobals::~CPDF_FontGlobals() {} diff --git a/core/fpdfapi/font/fpdf_font_cid.cpp b/core/fpdfapi/font/fpdf_font_cid.cpp index ddc0c12b7d..64b041738e 100644 --- a/core/fpdfapi/font/fpdf_font_cid.cpp +++ b/core/fpdfapi/font/fpdf_font_cid.cpp @@ -413,8 +413,8 @@ void CPDF_CMapParser::ParseWord(const CFX_ByteStringC& word) { FX_Free(m_pCMap->m_pLeadingBytes); m_pCMap->m_pLeadingBytes = FX_Alloc2D(uint8_t, nSegs, sizeof(CMap_CodeRange)); - FXSYS_memcpy(m_pCMap->m_pLeadingBytes, m_CodeRanges.data(), - nSegs * sizeof(CMap_CodeRange)); + memcpy(m_pCMap->m_pLeadingBytes, m_CodeRanges.data(), + nSegs * sizeof(CMap_CodeRange)); } else if (nSegs == 1) { m_pCMap->m_CodingScheme = (m_CodeRanges[0].m_CharSize == 2) ? CPDF_CMap::TwoBytes @@ -577,8 +577,8 @@ void CPDF_CMap::LoadEmbedded(const uint8_t* pData, uint32_t size) { if (m_CodingScheme == MixedFourBytes && parser.m_AddMaps.GetSize()) { m_pAddMapping = FX_Alloc(uint8_t, parser.m_AddMaps.GetSize() + 4); *(uint32_t*)m_pAddMapping = parser.m_AddMaps.GetSize() / 8; - FXSYS_memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), - parser.m_AddMaps.GetSize()); + memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), + parser.m_AddMaps.GetSize()); FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8, CompareDWORD); } @@ -720,7 +720,7 @@ int CPDF_CMap::AppendChar(char* str, uint32_t charcode) const { iSize = 1; } if (iSize > 1) { - FXSYS_memset(str, 0, sizeof(uint8_t) * iSize); + memset(str, 0, sizeof(uint8_t) * iSize); } str[iSize - 1] = (uint8_t)charcode; return iSize; diff --git a/core/fpdfapi/page/cpdf_color.cpp b/core/fpdfapi/page/cpdf_color.cpp index 46771513f4..f0e433c243 100644 --- a/core/fpdfapi/page/cpdf_color.cpp +++ b/core/fpdfapi/page/cpdf_color.cpp @@ -71,7 +71,7 @@ void CPDF_Color::SetValue(float* comps) { if (!m_pBuffer) return; if (m_pCS->GetFamily() != PDFCS_PATTERN) - FXSYS_memcpy(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(float)); + memcpy(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(float)); } void CPDF_Color::SetValue(CPDF_Pattern* pPattern, float* comps, int ncomps) { @@ -94,7 +94,7 @@ void CPDF_Color::SetValue(CPDF_Pattern* pPattern, float* comps, int ncomps) { pvalue->m_nComps = ncomps; pvalue->m_pPattern = pPattern; if (ncomps) - FXSYS_memcpy(pvalue->m_Comps, comps, ncomps * sizeof(float)); + memcpy(pvalue->m_Comps, comps, ncomps * sizeof(float)); pvalue->m_pCountedPattern = nullptr; if (pPattern && pPattern->document()) { @@ -120,7 +120,7 @@ void CPDF_Color::Copy(const CPDF_Color* pSrc) { return; m_pBuffer = m_pCS->CreateBuf(); - FXSYS_memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize()); + memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize()); if (m_pCS->GetFamily() != PDFCS_PATTERN) return; diff --git a/core/fpdfapi/page/cpdf_contentparser.cpp b/core/fpdfapi/page/cpdf_contentparser.cpp index 7ceb509348..46e2c52c75 100644 --- a/core/fpdfapi/page/cpdf_contentparser.cpp +++ b/core/fpdfapi/page/cpdf_contentparser.cpp @@ -142,7 +142,7 @@ void CPDF_ContentParser::Continue(IFX_Pause* pPause) { m_pData = FX_Alloc(uint8_t, m_Size); uint32_t pos = 0; for (const auto& stream : m_StreamArray) { - FXSYS_memcpy(m_pData + pos, stream->GetData(), stream->GetSize()); + memcpy(m_pData + pos, stream->GetData(), stream->GetSize()); pos += stream->GetSize(); m_pData[pos++] = ' '; } diff --git a/core/fpdfapi/page/cpdf_image.cpp b/core/fpdfapi/page/cpdf_image.cpp index 4fc1c344ef..da49fab8b1 100644 --- a/core/fpdfapi/page/cpdf_image.cpp +++ b/core/fpdfapi/page/cpdf_image.cpp @@ -269,8 +269,8 @@ void CPDF_Image::SetImage(const CFX_RetainPtr& pBitmap) { mask_buf.reset(FX_Alloc2D(uint8_t, maskHeight, maskWidth)); mask_size = maskHeight * maskWidth; // Safe since checked alloc returned. for (int32_t a = 0; a < maskHeight; a++) { - FXSYS_memcpy(mask_buf.get() + a * maskWidth, - pMaskBitmap->GetScanline(a), maskWidth); + memcpy(mask_buf.get() + a * maskWidth, pMaskBitmap->GetScanline(a), + maskWidth); } } pMaskDict->SetNewFor("Length", mask_size); @@ -288,7 +288,7 @@ void CPDF_Image::SetImage(const CFX_RetainPtr& pBitmap) { uint8_t* pDest = dest_buf; if (bCopyWithoutAlpha) { for (int32_t i = 0; i < BitmapHeight; i++) { - FXSYS_memcpy(pDest, src_buf, dest_pitch); + memcpy(pDest, src_buf, dest_pitch); pDest += dest_pitch; src_buf += src_pitch; } diff --git a/core/fpdfapi/page/cpdf_meshstream.cpp b/core/fpdfapi/page/cpdf_meshstream.cpp index c0074f84cc..b0a21c627a 100644 --- a/core/fpdfapi/page/cpdf_meshstream.cpp +++ b/core/fpdfapi/page/cpdf_meshstream.cpp @@ -210,7 +210,7 @@ std::tuple CPDF_MeshStream::ReadColor() { } float result[kMaxComponents]; - FXSYS_memset(result, 0, sizeof(result)); + memset(result, 0, sizeof(result)); int nResults; for (const auto& func : m_funcs) { if (func && func->CountOutputs() <= kMaxComponents) diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.cpp b/core/fpdfapi/page/cpdf_streamcontentparser.cpp index 59de3c50cb..30686133c2 100644 --- a/core/fpdfapi/page/cpdf_streamcontentparser.cpp +++ b/core/fpdfapi/page/cpdf_streamcontentparser.cpp @@ -326,11 +326,11 @@ void CPDF_StreamContentParser::AddNameParam(const CFX_ByteStringC& bsName) { } else { param.m_Type = ContentParam::NAME; if (bsName.Find('#') == -1) { - FXSYS_memcpy(param.m_Name.m_Buffer, bsName.raw_str(), bsName.GetLength()); + memcpy(param.m_Name.m_Buffer, bsName.raw_str(), bsName.GetLength()); param.m_Name.m_Len = bsName.GetLength(); } else { CFX_ByteString str = PDF_NameDecode(bsName); - FXSYS_memcpy(param.m_Name.m_Buffer, str.c_str(), str.GetLength()); + memcpy(param.m_Name.m_Buffer, str.c_str(), str.GetLength()); param.m_Name.m_Len = str.GetLength(); } } diff --git a/core/fpdfapi/page/cpdf_streamparser.cpp b/core/fpdfapi/page/cpdf_streamparser.cpp index f3a04fb117..3c4e534116 100644 --- a/core/fpdfapi/page/cpdf_streamparser.cpp +++ b/core/fpdfapi/page/cpdf_streamparser.cpp @@ -53,7 +53,7 @@ uint32_t DecodeAllScanlines(std::unique_ptr pDecoder, if (!pLine) break; - FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch); + memcpy(dest_buf + row * pitch, pLine, pitch); } return pDecoder->GetSrcOffset(); } @@ -184,7 +184,7 @@ std::unique_ptr CPDF_StreamParser::ReadInlineStream( if (OrigSize > m_Size - m_Pos) OrigSize = m_Size - m_Pos; pData.reset(FX_Alloc(uint8_t, OrigSize)); - FXSYS_memcpy(pData.get(), m_pBuf + m_Pos, OrigSize); + memcpy(pData.get(), m_pBuf + m_Pos, OrigSize); dwStreamSize = OrigSize; m_Pos += OrigSize; } else { @@ -217,7 +217,7 @@ std::unique_ptr CPDF_StreamParser::ReadInlineStream( } m_Pos = dwSavePos; pData.reset(FX_Alloc(uint8_t, dwStreamSize)); - FXSYS_memcpy(pData.get(), m_pBuf + m_Pos, dwStreamSize); + memcpy(pData.get(), m_pBuf + m_Pos, dwStreamSize); m_Pos += dwStreamSize; } pDict->SetNewFor("Length", (int)dwStreamSize); diff --git a/core/fpdfapi/page/fpdf_page_colors.cpp b/core/fpdfapi/page/fpdf_page_colors.cpp index adee5ff84b..ffb8da3a10 100644 --- a/core/fpdfapi/page/fpdf_page_colors.cpp +++ b/core/fpdfapi/page/fpdf_page_colors.cpp @@ -27,8 +27,7 @@ float NormalizeChannel(float fVal) { } bool DetectSRGB(const uint8_t* pData, uint32_t dwSize) { - return dwSize == 3144 && - FXSYS_memcmp(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0; + return dwSize == 3144 && memcmp(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0; } } // namespace diff --git a/core/fpdfapi/page/fpdf_page_func.cpp b/core/fpdfapi/page/fpdf_page_func.cpp index 8ea4194eaa..9be1edb7ff 100644 --- a/core/fpdfapi/page/fpdf_page_func.cpp +++ b/core/fpdfapi/page/fpdf_page_func.cpp @@ -801,8 +801,8 @@ bool CPDF_Function::Init(CPDF_Object* pObj) { if (m_pRanges && m_nOutputs > old_outputs) { m_pRanges = FX_Realloc(float, m_pRanges, m_nOutputs * 2); if (m_pRanges) { - FXSYS_memset(m_pRanges + (old_outputs * 2), 0, - sizeof(float) * (m_nOutputs - old_outputs) * 2); + memset(m_pRanges + (old_outputs * 2), 0, + sizeof(float) * (m_nOutputs - old_outputs) * 2); } } return true; diff --git a/core/fpdfapi/parser/cpdf_crypto_handler.cpp b/core/fpdfapi/parser/cpdf_crypto_handler.cpp index 61f78c4ee5..4fc7b3039b 100644 --- a/core/fpdfapi/parser/cpdf_crypto_handler.cpp +++ b/core/fpdfapi/parser/cpdf_crypto_handler.cpp @@ -21,7 +21,7 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, uint8_t* dest_buf, uint32_t& dest_size) { if (m_Cipher == FXCIPHER_NONE) { - FXSYS_memcpy(dest_buf, src_buf, src_size); + memcpy(dest_buf, src_buf, src_size); return; } uint8_t realkey[16]; @@ -31,7 +31,7 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, PopulateKey(objnum, gennum, key1); if (m_Cipher == FXCIPHER_AES) { - FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4); + memcpy(key1 + m_KeyLen + 5, "sAlT", 4); } CRYPT_MD5Generate( key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey); @@ -49,13 +49,12 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, iv[i] = (uint8_t)rand(); } CRYPT_AESSetIV(m_pAESContext, iv); - FXSYS_memcpy(dest_buf, iv, 16); + 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); + memcpy(padding, src_buf + nblocks * 16, src_size % 16); + 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; @@ -68,7 +67,7 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, } else { ASSERT(dest_size == src_size); if (dest_buf != src_buf) { - FXSYS_memcpy(dest_buf, src_buf, src_size); + memcpy(dest_buf, src_buf, src_size); } CRYPT_ArcFourCryptBlock(dest_buf, dest_size, realkey, realkeylen); } @@ -104,7 +103,7 @@ void* CPDF_CryptoHandler::CryptStart(uint32_t objnum, PopulateKey(objnum, gennum, key1); if (m_Cipher == FXCIPHER_AES) { - FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4); + memcpy(key1 + m_KeyLen + 5, "sAlT", 4); } uint8_t realkey[16]; CRYPT_MD5Generate( @@ -162,8 +161,8 @@ bool CPDF_CryptoHandler::CryptStream(void* context, if (copy_size > src_left) { copy_size = src_left; } - FXSYS_memcpy(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off, - copy_size); + 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; @@ -212,9 +211,9 @@ bool CPDF_CryptoHandler::CryptFinish(void* context, dest_buf.AppendBlock(block_buf, 16); pContext->m_BlockOffset = 0; } - FXSYS_memset(pContext->m_Block + pContext->m_BlockOffset, - (uint8_t)(16 - pContext->m_BlockOffset), - 16 - pContext->m_BlockOffset); + memset(pContext->m_Block + pContext->m_BlockOffset, + (uint8_t)(16 - pContext->m_BlockOffset), + 16 - pContext->m_BlockOffset); CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16); dest_buf.AppendBlock(block_buf, 16); } else if (pContext->m_BlockOffset == 16) { @@ -255,7 +254,7 @@ bool CPDF_CryptoHandler::Init(CPDF_Dictionary* pEncryptDict, return false; } if (m_Cipher != FXCIPHER_NONE) { - FXSYS_memcpy(m_EncryptKey, key, m_KeyLen); + memcpy(m_EncryptKey, key, m_KeyLen); } if (m_Cipher == FXCIPHER_AES) { m_pAESContext = FX_Alloc(uint8_t, 2048); @@ -288,7 +287,7 @@ bool CPDF_CryptoHandler::Init(int cipher, const uint8_t* key, int keylen) { } m_Cipher = cipher; m_KeyLen = keylen; - FXSYS_memcpy(m_EncryptKey, key, keylen); + memcpy(m_EncryptKey, key, keylen); if (m_Cipher == FXCIPHER_AES) { m_pAESContext = FX_Alloc(uint8_t, 2048); } @@ -333,7 +332,7 @@ CPDF_CryptoHandler::~CPDF_CryptoHandler() { void CPDF_CryptoHandler::PopulateKey(uint32_t objnum, uint32_t gennum, uint8_t* key) { - FXSYS_memcpy(key, m_EncryptKey, m_KeyLen); + memcpy(key, m_EncryptKey, m_KeyLen); key[m_KeyLen + 0] = (uint8_t)objnum; key[m_KeyLen + 1] = (uint8_t)(objnum >> 8); key[m_KeyLen + 2] = (uint8_t)(objnum >> 16); diff --git a/core/fpdfapi/parser/cpdf_document.cpp b/core/fpdfapi/parser/cpdf_document.cpp index 975592d044..b336acaf84 100644 --- a/core/fpdfapi/parser/cpdf_document.cpp +++ b/core/fpdfapi/parser/cpdf_document.cpp @@ -961,7 +961,7 @@ CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont, bool bVert, bool bTranslateName) { LOGFONTA lfa; - FXSYS_memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa); + memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa); CFX_ByteString face = CFX_ByteString::FromUnicode(pLogFont->lfFaceName); if (face.GetLength() >= LF_FACESIZE) return nullptr; diff --git a/core/fpdfapi/parser/cpdf_object_unittest.cpp b/core/fpdfapi/parser/cpdf_object_unittest.cpp index 3b5374b637..1923992d7a 100644 --- a/core/fpdfapi/parser/cpdf_object_unittest.cpp +++ b/core/fpdfapi/parser/cpdf_object_unittest.cpp @@ -162,8 +162,8 @@ class PDFObjectsTest : public testing::Test { // streams need to be handled. if (!stream1->IsMemoryBased() || !stream2->IsMemoryBased()) return false; - return FXSYS_memcmp(stream1->GetRawData(), stream2->GetRawData(), - stream1->GetRawSize()) == 0; + return memcmp(stream1->GetRawData(), stream2->GetRawData(), + stream1->GetRawSize()) == 0; } case CPDF_Object::REFERENCE: return obj1->AsReference()->GetRefObjNum() == diff --git a/core/fpdfapi/parser/cpdf_parser.cpp b/core/fpdfapi/parser/cpdf_parser.cpp index 323f91779c..cac678762d 100644 --- a/core/fpdfapi/parser/cpdf_parser.cpp +++ b/core/fpdfapi/parser/cpdf_parser.cpp @@ -1217,7 +1217,7 @@ void CPDF_Parser::GetIndirectBinary(uint32_t objnum, } pBuffer = FX_Alloc(uint8_t, size); - FXSYS_memcpy(pBuffer, pData + thisoff + offset, size); + memcpy(pBuffer, pData + thisoff + offset, size); return; } return; diff --git a/core/fpdfapi/parser/cpdf_security_handler.cpp b/core/fpdfapi/parser/cpdf_security_handler.cpp index cfc51350d9..44042cb47c 100644 --- a/core/fpdfapi/parser/cpdf_security_handler.cpp +++ b/core/fpdfapi/parser/cpdf_security_handler.cpp @@ -66,8 +66,8 @@ void CalcEncryptKey(CPDF_Dictionary* pEncrypt, CRYPT_MD5Generate(digest, copy_len, digest); } } - FXSYS_memset(key, 0, keylen); - FXSYS_memcpy(key, digest, copy_len); + memset(key, 0, keylen); + memcpy(key, digest, copy_len); } } // namespace @@ -303,7 +303,7 @@ void Revision6_Hash(const uint8_t* password, } FX_Free(aes); if (hash) { - FXSYS_memcpy(hash, input, 32); + memcpy(hash, input, 32); } } @@ -337,7 +337,7 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, CRYPT_SHA256Finish(&sha, digest); } - if (FXSYS_memcmp(digest, pkey, 32) != 0) + if (memcmp(digest, pkey, 32) != 0) return false; if (!key) @@ -364,7 +364,7 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, std::vector aes(2048); CRYPT_AESSetKey(aes.data(), 16, digest, 32, false); uint8_t iv[16]; - FXSYS_memset(iv, 0, 16); + memset(iv, 0, 16); CRYPT_AESSetIV(aes.data(), iv); CRYPT_AESDecrypt(aes.data(), key, ekey.raw_str(), 32); CRYPT_AESSetKey(aes.data(), 16, key, 32, false); @@ -374,10 +374,10 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, return false; uint8_t perms_buf[16]; - FXSYS_memset(perms_buf, 0, sizeof(perms_buf)); + memset(perms_buf, 0, sizeof(perms_buf)); size_t copy_len = std::min(sizeof(perms_buf), static_cast(perms.GetLength())); - FXSYS_memcpy(perms_buf, perms.raw_str(), copy_len); + memcpy(perms_buf, perms.raw_str(), copy_len); uint8_t buf[16]; CRYPT_AESDecrypt(aes.data(), buf, perms_buf, 16); if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') @@ -425,7 +425,7 @@ bool CPDF_SecurityHandler::CheckUserPassword(const uint8_t* password, } uint8_t ukeybuf[32]; if (m_Revision == 2) { - FXSYS_memcpy(ukeybuf, defpasscode, 32); + memcpy(ukeybuf, defpasscode, 32); CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len); } else { uint8_t test[32], tmpkey[32]; @@ -433,9 +433,9 @@ bool CPDF_SecurityHandler::CheckUserPassword(const uint8_t* password, if (copy_len > (uint32_t)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); + memset(test, 0, sizeof(test)); + memset(tmpkey, 0, sizeof(tmpkey)); + memcpy(test, ukey.c_str(), copy_len); for (int32_t i = 19; i >= 0; i--) { for (int j = 0; j < key_len; j++) tmpkey[j] = key[j] ^ static_cast(i); @@ -450,9 +450,9 @@ bool CPDF_SecurityHandler::CheckUserPassword(const uint8_t* password, CRYPT_MD5Update(&md5, (uint8_t*)id.c_str(), id.GetLength()); } CRYPT_MD5Finish(&md5, ukeybuf); - return FXSYS_memcmp(test, ukeybuf, 16) == 0; + return memcmp(test, ukeybuf, 16) == 0; } - if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) { + if (memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) { return true; } return false; @@ -473,25 +473,25 @@ CFX_ByteString CPDF_SecurityHandler::GetUserPassword(const uint8_t* owner_pass, } } uint8_t enckey[32]; - FXSYS_memset(enckey, 0, sizeof(enckey)); + memset(enckey, 0, sizeof(enckey)); uint32_t copy_len = key_len; if (copy_len > sizeof(digest)) { copy_len = sizeof(digest); } - FXSYS_memcpy(enckey, digest, copy_len); + 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); + memset(okeybuf, 0, sizeof(okeybuf)); + memcpy(okeybuf, okey.c_str(), okeylen); if (m_Revision == 2) { CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len); } else { for (int32_t i = 19; i >= 0; i--) { uint8_t tempkey[32]; - FXSYS_memset(tempkey, 0, sizeof(tempkey)); + memset(tempkey, 0, sizeof(tempkey)); for (int j = 0; j < m_KeyLen; j++) tempkey[j] = enckey[j] ^ static_cast(i); CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len); @@ -567,7 +567,7 @@ void CPDF_SecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CRYPT_MD5Generate(digest, 16, digest); } uint8_t enckey[32]; - FXSYS_memcpy(enckey, digest, key_len); + memcpy(enckey, digest, key_len); for (uint32_t i = 0; i < 32; i++) { passcode[i] = i < user_size ? user_pass[i] : defpasscode[i - user_size]; } @@ -587,7 +587,7 @@ void CPDF_SecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, key_len, false, pIdArray); if (m_Revision < 3) { uint8_t tempbuf[32]; - FXSYS_memcpy(tempbuf, defpasscode, 32); + memcpy(tempbuf, defpasscode, 32); CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len); pEncryptDict->SetNewFor("U", CFX_ByteString(tempbuf, 32), false); @@ -660,7 +660,7 @@ void CPDF_SecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, } CRYPT_SHA256Finish(&sha2, digest1); } - FXSYS_memcpy(digest1 + 32, digest, 16); + memcpy(digest1 + 32, digest, 16); pEncryptDict->SetNewFor(bOwner ? "O" : "U", CFX_ByteString(digest1, 48), false); if (m_Revision >= 6) { @@ -678,7 +678,7 @@ void CPDF_SecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, uint8_t* aes = FX_Alloc(uint8_t, 2048); CRYPT_AESSetKey(aes, 16, digest1, 32, true); uint8_t iv[16]; - FXSYS_memset(iv, 0, 16); + memset(iv, 0, 16); CRYPT_AESSetIV(aes, iv); CRYPT_AESEncrypt(aes, digest1, key, 32); FX_Free(aes); @@ -706,7 +706,7 @@ void CPDF_SecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, uint8_t* aes = FX_Alloc(uint8_t, 2048); CRYPT_AESSetKey(aes, 16, key, 32, true); uint8_t iv[16], buf1[16]; - FXSYS_memset(iv, 0, 16); + memset(iv, 0, 16); CRYPT_AESSetIV(aes, iv); CRYPT_AESEncrypt(aes, buf1, buf, 16); FX_Free(aes); diff --git a/core/fpdfapi/parser/cpdf_stream.cpp b/core/fpdfapi/parser/cpdf_stream.cpp index d62b45641b..532fd753f8 100644 --- a/core/fpdfapi/parser/cpdf_stream.cpp +++ b/core/fpdfapi/parser/cpdf_stream.cpp @@ -57,7 +57,7 @@ void CPDF_Stream::InitStream(const uint8_t* pData, m_pFile = nullptr; m_pDataBuf.reset(FX_Alloc(uint8_t, size)); if (pData) - FXSYS_memcpy(m_pDataBuf.get(), pData, size); + memcpy(m_pDataBuf.get(), pData, size); m_dwSize = size; if (m_pDict) m_pDict->SetNewFor("Length", static_cast(m_dwSize)); @@ -101,7 +101,7 @@ void CPDF_Stream::SetData(const uint8_t* pData, uint32_t size) { m_bMemoryBased = true; m_pDataBuf.reset(FX_Alloc(uint8_t, size)); if (pData) - FXSYS_memcpy(m_pDataBuf.get(), pData, size); + memcpy(m_pDataBuf.get(), pData, size); m_dwSize = size; if (!m_pDict) m_pDict = pdfium::MakeUnique(); @@ -117,7 +117,7 @@ bool CPDF_Stream::ReadRawData(FX_FILESIZE offset, return m_pFile->ReadBlock(buf, offset, size); if (m_pDataBuf) - FXSYS_memcpy(buf, m_pDataBuf.get() + offset, size); + memcpy(buf, m_pDataBuf.get() + offset, size); return true; } diff --git a/core/fpdfapi/parser/cpdf_stream_acc.cpp b/core/fpdfapi/parser/cpdf_stream_acc.cpp index 423de7c571..59ac289b7c 100644 --- a/core/fpdfapi/parser/cpdf_stream_acc.cpp +++ b/core/fpdfapi/parser/cpdf_stream_acc.cpp @@ -82,6 +82,6 @@ std::unique_ptr CPDF_StreamAcc::DetachData() { return p; } std::unique_ptr p(FX_Alloc(uint8_t, m_dwSize)); - FXSYS_memcpy(p.get(), m_pData, m_dwSize); + memcpy(p.get(), m_pData, m_dwSize); return p; } diff --git a/core/fpdfapi/parser/cpdf_syntax_parser.cpp b/core/fpdfapi/parser/cpdf_syntax_parser.cpp index 54fb89a48b..67c0977cfe 100644 --- a/core/fpdfapi/parser/cpdf_syntax_parser.cpp +++ b/core/fpdfapi/parser/cpdf_syntax_parser.cpp @@ -645,13 +645,13 @@ std::unique_ptr CPDF_SyntaxParser::ReadStream( m_Pos = pos.ValueOrDie(); m_Pos += ReadEOLMarkers(m_Pos); - FXSYS_memset(m_WordBuffer, 0, kEndStreamStr.GetLength() + 1); + memset(m_WordBuffer, 0, kEndStreamStr.GetLength() + 1); GetNextWordInternal(nullptr); // Earlier version of PDF specification doesn't require EOL marker before // 'endstream' keyword. If keyword 'endstream' follows the bytes in // specified length, it signals the end of stream. - if (FXSYS_memcmp(m_WordBuffer, kEndStreamStr.raw_str(), - kEndStreamStr.GetLength()) == 0) { + if (memcmp(m_WordBuffer, kEndStreamStr.raw_str(), + kEndStreamStr.GetLength()) == 0) { bSearchForKeyword = false; } } @@ -750,14 +750,13 @@ std::unique_ptr CPDF_SyntaxParser::ReadStream( auto pStream = pdfium::MakeUnique(std::move(pData), len, std::move(pDict)); streamStartPos = m_Pos; - FXSYS_memset(m_WordBuffer, 0, kEndObjStr.GetLength() + 1); + memset(m_WordBuffer, 0, kEndObjStr.GetLength() + 1); GetNextWordInternal(nullptr); int numMarkers = ReadEOLMarkers(m_Pos); if (m_WordSize == static_cast(kEndObjStr.GetLength()) && numMarkers != 0 && - FXSYS_memcmp(m_WordBuffer, kEndObjStr.raw_str(), - kEndObjStr.GetLength()) == 0) { + memcmp(m_WordBuffer, kEndObjStr.raw_str(), kEndObjStr.GetLength()) == 0) { m_Pos = streamStartPos; } return pStream; diff --git a/core/fpdfapi/parser/fpdf_parser_decode.cpp b/core/fpdfapi/parser/fpdf_parser_decode.cpp index af1f452afd..a1698aedde 100644 --- a/core/fpdfapi/parser/fpdf_parser_decode.cpp +++ b/core/fpdfapi/parser/fpdf_parser_decode.cpp @@ -114,7 +114,7 @@ uint32_t A85Decode(const uint8_t* src_buf, continue; if (ch == 'z') { - FXSYS_memset(dest_buf + dest_size, 0, 4); + memset(dest_buf + dest_size, 0, 4); state = 0; res = 0; dest_size += 4; @@ -226,9 +226,9 @@ uint32_t RunLengthDecode(const uint8_t* src_buf, if (buf_left < copy_len) { uint32_t delta = copy_len - buf_left; copy_len = buf_left; - FXSYS_memset(dest_buf + dest_count + copy_len, '\0', delta); + memset(dest_buf + dest_count + copy_len, '\0', delta); } - FXSYS_memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len); + memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len); dest_count += src_buf[i] + 1; i += src_buf[i] + 2; } else { @@ -236,7 +236,7 @@ uint32_t RunLengthDecode(const uint8_t* src_buf, if (i < src_size - 1) { fill = src_buf[i + 1]; } - FXSYS_memset(dest_buf + dest_count, fill, 257 - src_buf[i]); + memset(dest_buf + dest_count, fill, 257 - src_buf[i]); dest_count += 257 - src_buf[i]; i += 2; } diff --git a/core/fpdfapi/render/cpdf_dibsource.cpp b/core/fpdfapi/render/cpdf_dibsource.cpp index cb8e9c9eee..12bfadb19d 100644 --- a/core/fpdfapi/render/cpdf_dibsource.cpp +++ b/core/fpdfapi/render/cpdf_dibsource.cpp @@ -999,7 +999,7 @@ const uint8_t* CPDF_DIBSource::GetScanline(int line) const { } if (!pSrcLine) { uint8_t* pLineBuf = m_pMaskedLine ? m_pMaskedLine : m_pLineBuf; - FXSYS_memset(pLineBuf, 0xFF, m_Pitch); + memset(pLineBuf, 0xFF, m_Pitch); return pLineBuf; } if (m_bpc * m_nComponents == 1) { @@ -1030,13 +1030,13 @@ const uint8_t* CPDF_DIBSource::GetScanline(int line) const { } return m_pMaskedLine; } else { - FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value); + memcpy(m_pLineBuf, pSrcLine, src_pitch_value); } return m_pLineBuf; } if (m_bpc * m_nComponents <= 8) { if (m_bpc == 8) { - FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value); + memcpy(m_pLineBuf, pSrcLine, src_pitch_value); } else { uint64_t src_bit_pos = 0; for (int col = 0; col < m_Width; col++) { @@ -1088,7 +1088,7 @@ const uint8_t* CPDF_DIBSource::GetScanline(int line) const { : 0; } } else { - FXSYS_memset(m_pMaskedLine, 0xFF, m_Pitch); + memset(m_pMaskedLine, 0xFF, m_Pitch); } } if (m_pColorSpace) { @@ -1149,7 +1149,7 @@ void CPDF_DIBSource::DownSampleScanline(int line, int orig_Bpp = m_bpc * m_nComponents / 8; int dest_Bpp = dest_bpp / 8; if (!pSrcLine) { - FXSYS_memset(dest_scan, 0xFF, dest_Bpp * clip_width); + memset(dest_scan, 0xFF, dest_Bpp * clip_width); return; } diff --git a/core/fpdfapi/render/cpdf_docrenderdata.cpp b/core/fpdfapi/render/cpdf_docrenderdata.cpp index 1c430e8f0f..b34fa2caef 100644 --- a/core/fpdfapi/render/cpdf_docrenderdata.cpp +++ b/core/fpdfapi/render/cpdf_docrenderdata.cpp @@ -110,7 +110,7 @@ CPDF_TransferFunc* CPDF_DocRenderData::GetTransferFunc(CPDF_Object* pObj) { CPDF_TransferFunc* pTransfer = pTransferCounter->get(); m_TransferFuncMap[pObj] = pTransferCounter; float output[kMaxOutputs]; - FXSYS_memset(output, 0, sizeof(output)); + memset(output, 0, sizeof(output)); float input; int noutput; for (int v = 0; v < 256; ++v) { diff --git a/core/fpdfapi/render/cpdf_renderstatus.cpp b/core/fpdfapi/render/cpdf_renderstatus.cpp index f2d888bdeb..97bb0ac4a2 100644 --- a/core/fpdfapi/render/cpdf_renderstatus.cpp +++ b/core/fpdfapi/render/cpdf_renderstatus.cpp @@ -137,7 +137,7 @@ void DrawAxialShading(const CFX_RetainPtr& pBitmap, std::max(CountOutputs(funcs), pCS->CountComponents()); CFX_FixedBufGrow result_array(total_results); float* pResults = result_array; - FXSYS_memset(pResults, 0, total_results * sizeof(float)); + memset(pResults, 0, total_results * sizeof(float)); uint32_t rgb_array[SHADING_STEPS]; for (int i = 0; i < SHADING_STEPS; i++) { float input = (t_max - t_min) * i / SHADING_STEPS + t_min; @@ -220,7 +220,7 @@ void DrawRadialShading(const CFX_RetainPtr& pBitmap, std::max(CountOutputs(funcs), pCS->CountComponents()); CFX_FixedBufGrow result_array(total_results); float* pResults = result_array; - FXSYS_memset(pResults, 0, total_results * sizeof(float)); + memset(pResults, 0, total_results * sizeof(float)); uint32_t rgb_array[SHADING_STEPS]; for (int i = 0; i < SHADING_STEPS; i++) { float input = (t_max - t_min) * i / SHADING_STEPS + t_min; @@ -345,7 +345,7 @@ void DrawFuncShading(const CFX_RetainPtr& pBitmap, std::max(CountOutputs(funcs), pCS->CountComponents()); CFX_FixedBufGrow result_array(total_results); float* pResults = result_array; - FXSYS_memset(pResults, 0, total_results * sizeof(float)); + memset(pResults, 0, total_results * sizeof(float)); for (int row = 0; row < height; row++) { uint32_t* dib_buf = (uint32_t*)(pBitmap->GetBuffer() + row * pitch); for (int column = 0; column < width; column++) { @@ -487,7 +487,7 @@ void DrawFreeGouraudShading( return; CPDF_MeshVertex triangle[3]; - FXSYS_memset(triangle, 0, sizeof(triangle)); + memset(triangle, 0, sizeof(triangle)); while (!stream.BitStream()->IsEOF()) { CPDF_MeshVertex vertex; @@ -685,7 +685,7 @@ int BiInterpolImpl(int c0, } struct Coon_Color { - Coon_Color() { FXSYS_memset(comp, 0, sizeof(int) * 3); } + Coon_Color() { memset(comp, 0, sizeof(int) * 3); } int comp[3]; void BiInterpol(Coon_Color colors[4], @@ -848,11 +848,11 @@ void DrawCoonPatchMeshes( for (i = 0; i < 4; i++) { tempCoords[i] = coords[(flag * 3 + i) % 12]; } - FXSYS_memcpy(coords, tempCoords, sizeof(tempCoords)); + memcpy(coords, tempCoords, sizeof(tempCoords)); Coon_Color tempColors[2]; tempColors[0] = patch.patch_colors[flag]; tempColors[1] = patch.patch_colors[(flag + 1) % 4]; - FXSYS_memcpy(patch.patch_colors, tempColors, sizeof(Coon_Color) * 2); + memcpy(patch.patch_colors, tempColors, sizeof(Coon_Color) * 2); } for (i = iStartPoint; i < point_count; i++) { if (!stream.CanReadCoords()) @@ -2586,7 +2586,7 @@ CFX_RetainPtr CPDF_RenderStatus::LoadSMask( if (!num_floats.IsValid()) { return nullptr; } - FXSYS_memset(pFloats, 0, num_floats.ValueOrDie()); + memset(pFloats, 0, num_floats.ValueOrDie()); size_t count = pBC->GetCount() > 8 ? 8 : pBC->GetCount(); for (size_t i = 0; i < count; i++) { pFloats[i] = pBC->GetNumberAt(i); @@ -2651,7 +2651,7 @@ CFX_RetainPtr CPDF_RenderStatus::LoadSMask( dest_buf[i] = transfers[src_buf[i]]; } } else { - FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height); + memcpy(dest_buf, src_buf, dest_pitch * height); } return pMask; } diff --git a/core/fpdftext/cpdf_textpagefind.cpp b/core/fpdftext/cpdf_textpagefind.cpp index e268975aa7..7eaac35194 100644 --- a/core/fpdftext/cpdf_textpagefind.cpp +++ b/core/fpdftext/cpdf_textpagefind.cpp @@ -381,7 +381,7 @@ bool CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString, int nLen = lpchEnd ? (int)(lpchEnd - lpszFullString) : (int)FXSYS_wcslen(lpszFullString); ASSERT(nLen >= 0); - FXSYS_memcpy(rString.GetBuffer(nLen), lpszFullString, nLen * sizeof(wchar_t)); + memcpy(rString.GetBuffer(nLen), lpszFullString, nLen * sizeof(wchar_t)); rString.ReleaseBuffer(); return true; } diff --git a/core/fxcodec/codec/ccodec_bmpmodule.cpp b/core/fxcodec/codec/ccodec_bmpmodule.cpp index d891a37ee4..660e89c4a0 100644 --- a/core/fxcodec/codec/ccodec_bmpmodule.cpp +++ b/core/fxcodec/codec/ccodec_bmpmodule.cpp @@ -56,7 +56,7 @@ FXBMP_Context* CCodec_BmpModule::Start() { if (!p) return nullptr; - FXSYS_memset(p, 0, sizeof(FXBMP_Context)); + memset(p, 0, sizeof(FXBMP_Context)); if (!p) return nullptr; diff --git a/core/fxcodec/codec/ccodec_gifmodule.cpp b/core/fxcodec/codec/ccodec_gifmodule.cpp index b7352ba53c..caa21e1424 100644 --- a/core/fxcodec/codec/ccodec_gifmodule.cpp +++ b/core/fxcodec/codec/ccodec_gifmodule.cpp @@ -88,7 +88,7 @@ FXGIF_Context* CCodec_GifModule::Start() { if (!p) return nullptr; - FXSYS_memset(p, 0, sizeof(FXGIF_Context)); + memset(p, 0, sizeof(FXGIF_Context)); p->m_AllocFunc = gif_alloc_func; p->m_FreeFunc = gif_free_func; p->gif_ptr = nullptr; @@ -177,7 +177,7 @@ int32_t CCodec_GifModule::LoadFrame(FXGIF_Context* ctx, buf += size; size = *buf++; if (size == 20) { - FXSYS_memcpy(pAttribute->m_strTime, buf, size); + memcpy(pAttribute->m_strTime, buf, size); } } } diff --git a/core/fxcodec/codec/ccodec_pngmodule.cpp b/core/fxcodec/codec/ccodec_pngmodule.cpp index 2b8f95799e..ae34b53413 100644 --- a/core/fxcodec/codec/ccodec_pngmodule.cpp +++ b/core/fxcodec/codec/ccodec_pngmodule.cpp @@ -55,7 +55,7 @@ static void _png_load_bmp_attribute(png_structp png_ptr, png_timep t = nullptr; png_get_tIME(png_ptr, info_ptr, &t); if (t) { - FXSYS_memset(pAttribute->m_strTime, 0, sizeof(pAttribute->m_strTime)); + memset(pAttribute->m_strTime, 0, sizeof(pAttribute->m_strTime)); FXSYS_snprintf((char*)pAttribute->m_strTime, sizeof(pAttribute->m_strTime), "%4u:%2u:%2u %2u:%2u:%2u", t->year, t->month, t->day, t->hour, t->minute, t->second); @@ -73,16 +73,16 @@ static void _png_load_bmp_attribute(png_structp png_ptr, for (i = 0; i < num_text; i++) { len = FXSYS_strlen(text[i].key); buf = "Time"; - if (!FXSYS_memcmp(buf, text[i].key, std::min(len, FXSYS_strlen(buf)))) { + if (!memcmp(buf, text[i].key, std::min(len, FXSYS_strlen(buf)))) { if (!bTime) { - FXSYS_memset(pAttribute->m_strTime, 0, sizeof(pAttribute->m_strTime)); - FXSYS_memcpy( + memset(pAttribute->m_strTime, 0, sizeof(pAttribute->m_strTime)); + memcpy( pAttribute->m_strTime, text[i].text, std::min(sizeof(pAttribute->m_strTime) - 1, text[i].text_length)); } } else { buf = "Author"; - if (!FXSYS_memcmp(buf, text[i].key, std::min(len, FXSYS_strlen(buf)))) { + if (!memcmp(buf, text[i].key, std::min(len, FXSYS_strlen(buf)))) { pAttribute->m_strAuthor = CFX_ByteString(reinterpret_cast(text[i].text), static_cast(text[i].text_length)); diff --git a/core/fxcodec/codec/ccodec_tiffmodule.cpp b/core/fxcodec/codec/ccodec_tiffmodule.cpp index 0a0b56ce94..cc51677abd 100644 --- a/core/fxcodec/codec/ccodec_tiffmodule.cpp +++ b/core/fxcodec/codec/ccodec_tiffmodule.cpp @@ -74,15 +74,15 @@ void* _TIFFrealloc(void* ptr, tmsize_t size) { } void _TIFFmemset(void* ptr, int val, tmsize_t size) { - FXSYS_memset(ptr, val, (size_t)size); + memset(ptr, val, (size_t)size); } void _TIFFmemcpy(void* des, const void* src, tmsize_t size) { - FXSYS_memcpy(des, src, (size_t)size); + memcpy(des, src, (size_t)size); } int _TIFFmemcmp(const void* ptr1, const void* ptr2, tmsize_t size) { - return FXSYS_memcmp(ptr1, ptr2, (size_t)size); + return memcmp(ptr1, ptr2, (size_t)size); } int _TIFFIfMultiplicationOverflow(tmsize_t op1, tmsize_t op2) { @@ -199,7 +199,7 @@ void Tiff_Exif_GetStringInfo(TIFF* tif_ctx, return; FX_STRSIZE size = FXSYS_strlen(buf); uint8_t* ptr = FX_Alloc(uint8_t, size + 1); - FXSYS_memcpy(ptr, buf, size); + memcpy(ptr, buf, size); ptr[size] = 0; pAttr->m_Exif[tag] = ptr; } diff --git a/core/fxcodec/codec/fx_codec.cpp b/core/fxcodec/codec/fx_codec.cpp index 0d886b43cb..900fed2d87 100644 --- a/core/fxcodec/codec/fx_codec.cpp +++ b/core/fxcodec/codec/fx_codec.cpp @@ -254,7 +254,7 @@ CFX_DIBAttribute::CFX_DIBAttribute() m_pGifLocalPalette(nullptr), m_nGifLocalPalNum(0), m_nBmpCompressType(0) { - FXSYS_memset(m_strTime, 0, sizeof(m_strTime)); + memset(m_strTime, 0, sizeof(m_strTime)); } CFX_DIBAttribute::~CFX_DIBAttribute() { for (const auto& pair : m_Exif) @@ -361,7 +361,7 @@ bool CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, return CheckDestSize(); } bool CCodec_RLScanlineDecoder::v_Rewind() { - FXSYS_memset(m_pScanline, 0, m_Pitch); + memset(m_pScanline, 0, m_Pitch); m_SrcOffset = 0; m_bEOD = false; m_Operator = 0; @@ -375,7 +375,7 @@ uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() { return nullptr; } } - FXSYS_memset(m_pScanline, 0, m_Pitch); + memset(m_pScanline, 0, m_Pitch); uint32_t col_pos = 0; bool eol = false; while (m_SrcOffset < m_SrcSize && !eol) { @@ -389,7 +389,7 @@ uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() { copy_len = m_SrcSize - m_SrcOffset; m_bEOD = true; } - FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len); + memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len); col_pos += copy_len; UpdateOperator((uint8_t)copy_len); } else if (m_Operator > 128) { @@ -402,7 +402,7 @@ uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() { duplicate_len = m_dwLineBytes - col_pos; eol = true; } - FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len); + memset(m_pScanline + col_pos, fill, duplicate_len); col_pos += duplicate_len; UpdateOperator((uint8_t)duplicate_len); } else { diff --git a/core/fxcodec/codec/fx_codec_fax.cpp b/core/fxcodec/codec/fx_codec_fax.cpp index 7865da925e..641e0fd9d1 100644 --- a/core/fxcodec/codec/fx_codec_fax.cpp +++ b/core/fxcodec/codec/fx_codec_fax.cpp @@ -123,7 +123,7 @@ void FaxFillBits(uint8_t* dest_buf, int columns, int startpos, int endpos) { dest_buf[last_byte] -= 1 << (7 - i); if (last_byte > first_byte + 1) - FXSYS_memset(dest_buf + first_byte + 1, 0, last_byte - first_byte - 1); + memset(dest_buf + first_byte + 1, 0, last_byte - first_byte - 1); } inline bool NextBit(const uint8_t* src_buf, int* bitpos) { @@ -502,7 +502,7 @@ CCodec_FaxDecoder::CCodec_FaxDecoder(const uint8_t* src_buf, CCodec_FaxDecoder::~CCodec_FaxDecoder() {} bool CCodec_FaxDecoder::v_Rewind() { - FXSYS_memset(m_RefBuf.data(), 0xff, m_RefBuf.size()); + memset(m_RefBuf.data(), 0xff, m_RefBuf.size()); m_bitpos = 0; return true; } @@ -513,7 +513,7 @@ uint8_t* CCodec_FaxDecoder::v_GetNextLine() { if (m_bitpos >= bitsize) return nullptr; - FXSYS_memset(m_ScanlineBuf.data(), 0xff, m_ScanlineBuf.size()); + memset(m_ScanlineBuf.data(), 0xff, m_ScanlineBuf.size()); if (m_Encoding < 0) { FaxG4GetRow(m_pSrcBuf, bitsize, &m_bitpos, m_ScanlineBuf.data(), m_RefBuf, m_OrigWidth); @@ -570,9 +570,9 @@ void FaxG4Decode(const uint8_t* src_buf, int bitpos = *pbitpos; for (int iRow = 0; iRow < height; iRow++) { uint8_t* line_buf = dest_buf + iRow * pitch; - FXSYS_memset(line_buf, 0xff, pitch); + memset(line_buf, 0xff, pitch); FaxG4GetRow(src_buf, src_size << 3, &bitpos, line_buf, ref_buf, width); - FXSYS_memcpy(ref_buf.data(), line_buf, pitch); + memcpy(ref_buf.data(), line_buf, pitch); } *pbitpos = bitpos; } @@ -756,7 +756,7 @@ CCodec_FaxEncoder::CCodec_FaxEncoder(const uint8_t* src_buf, int pitch) : m_Cols(width), m_Rows(height), m_Pitch(pitch), m_pSrcBuf(src_buf) { m_RefLine.resize(m_Pitch); - FXSYS_memset(m_RefLine.data(), 0xff, m_Pitch); + memset(m_RefLine.data(), 0xff, m_Pitch); m_pLineBuf = FX_Alloc2D(uint8_t, m_Pitch, 8); m_DestBuf.EstimateSize(0, 10240); } @@ -772,13 +772,13 @@ void CCodec_FaxEncoder::Encode( uint8_t last_byte = 0; for (int i = 0; i < m_Rows; i++) { const uint8_t* scan_line = m_pSrcBuf + i * m_Pitch; - FXSYS_memset(m_pLineBuf, 0, m_Pitch * 8); + memset(m_pLineBuf, 0, m_Pitch * 8); m_pLineBuf[0] = last_byte; FaxEncode2DLine(m_pLineBuf, &dest_bitpos, scan_line, m_RefLine, m_Cols); m_DestBuf.AppendBlock(m_pLineBuf, dest_bitpos / 8); last_byte = m_pLineBuf[dest_bitpos / 8]; dest_bitpos %= 8; - FXSYS_memcpy(m_RefLine.data(), scan_line, m_Pitch); + memcpy(m_RefLine.data(), scan_line, m_Pitch); } if (dest_bitpos) m_DestBuf.AppendByte(last_byte); diff --git a/core/fxcodec/codec/fx_codec_flate.cpp b/core/fxcodec/codec/fx_codec_flate.cpp index dd9c4c9fa6..2ac316100a 100644 --- a/core/fxcodec/codec/fx_codec_flate.cpp +++ b/core/fxcodec/codec/fx_codec_flate.cpp @@ -52,7 +52,7 @@ bool FlateCompress(unsigned char* dest_buf, void* FlateInit() { z_stream* p = FX_Alloc(z_stream, 1); - FXSYS_memset(p, 0, sizeof(z_stream)); + memset(p, 0, sizeof(z_stream)); p->zalloc = my_alloc_func; p->zfree = my_free_func; inflateInit(p); @@ -80,7 +80,7 @@ uint32_t FlateOutput(void* context, uint32_t written = post_pos - pre_pos; if (written < dest_size) - FXSYS_memset(dest_buf + written, '\0', dest_size - written); + memset(dest_buf + written, '\0', dest_size - written); return ret; } @@ -290,7 +290,7 @@ void PNG_PredictLine(uint8_t* pDestData, int BytesPerPixel = (bpc * nColors + 7) / 8; uint8_t tag = pSrcData[0]; if (tag == 0) { - FXSYS_memmove(pDestData, pSrcData + 1, row_size); + memmove(pDestData, pSrcData + 1, row_size); return; } for (int byte = 0; byte < row_size; byte++) { @@ -372,7 +372,7 @@ bool PNG_Predictor(uint8_t*& data_buf, if ((row + 1) * (move_size + 1) > (int)data_size) { move_size = last_row_size - 1; } - FXSYS_memmove(pDestData, pSrcData + 1, move_size); + memmove(pDestData, pSrcData + 1, move_size); pSrcData += move_size + 1; pDestData += move_size; byte_cnt += move_size; @@ -603,7 +603,7 @@ void FlateUncompress(const uint8_t* src_buf, tmp_buf_size = last_buf_size; uint32_t cp_size = std::min(tmp_buf_size, remaining); - FXSYS_memcpy(result_buf + result_pos, tmp_buf, cp_size); + memcpy(result_buf + result_pos, tmp_buf, cp_size); result_pos += cp_size; remaining -= cp_size; @@ -736,7 +736,7 @@ uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns); - FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch); + memcpy(m_pLastLine, m_pScanline, m_PredictPitch); } else { FlateOutput(m_pFlate, m_pScanline, m_Pitch); TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps, @@ -747,9 +747,8 @@ uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { size_t read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver; if (read_leftover) { - FXSYS_memcpy(m_pScanline, - m_pPredictBuffer + m_PredictPitch - m_LeftOver, - read_leftover); + memcpy(m_pScanline, m_pPredictBuffer + m_PredictPitch - m_LeftOver, + read_leftover); m_LeftOver -= read_leftover; bytes_to_go -= read_leftover; } @@ -758,7 +757,7 @@ uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1); PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns); - FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch); + memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch); } else { FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch); TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent, @@ -766,8 +765,8 @@ uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() { } size_t read_bytes = m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch; - FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, - read_bytes); + memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, + read_bytes); m_LeftOver += m_PredictPitch - read_bytes; bytes_to_go -= read_bytes; } @@ -873,7 +872,7 @@ bool CCodec_FlateModule::PngEncode(const uint8_t* src_buf, uint8_t** dest_buf, uint32_t* dest_size) { uint8_t* pSrcBuf = FX_Alloc(uint8_t, src_size); - FXSYS_memcpy(pSrcBuf, src_buf, src_size); + memcpy(pSrcBuf, src_buf, src_size); PNG_PredictorEncode(&pSrcBuf, &src_size); bool ret = Encode(pSrcBuf, src_size, dest_buf, dest_size); FX_Free(pSrcBuf); diff --git a/core/fxcodec/codec/fx_codec_jbig.cpp b/core/fxcodec/codec/fx_codec_jbig.cpp index 926541f07d..dc82305616 100644 --- a/core/fxcodec/codec/fx_codec_jbig.cpp +++ b/core/fxcodec/codec/fx_codec_jbig.cpp @@ -62,7 +62,7 @@ FXCODEC_STATUS CCodec_Jbig2Module::StartDecode( pJbig2Context->m_dest_buf = dest_buf; pJbig2Context->m_dest_pitch = dest_pitch; pJbig2Context->m_pPause = pPause; - FXSYS_memset(dest_buf, 0, height * dest_pitch); + memset(dest_buf, 0, height * dest_pitch); pJbig2Context->m_pContext = pdfium::MakeUnique( global_stream, src_stream, pJBig2DocumentContext->GetSymbolDictCache(), pPause, false); diff --git a/core/fxcodec/codec/fx_codec_jpeg.cpp b/core/fxcodec/codec/fx_codec_jpeg.cpp index 0431560529..584148d148 100644 --- a/core/fxcodec/codec/fx_codec_jpeg.cpp +++ b/core/fxcodec/codec/fx_codec_jpeg.cpp @@ -185,9 +185,9 @@ CCodec_JpegDecoder::CCodec_JpegDecoder() { m_pScanlineBuf = nullptr; m_bStarted = false; m_bInited = false; - FXSYS_memset(&cinfo, 0, sizeof(cinfo)); - FXSYS_memset(&jerr, 0, sizeof(jerr)); - FXSYS_memset(&src, 0, sizeof(src)); + memset(&cinfo, 0, sizeof(cinfo)); + memset(&jerr, 0, sizeof(jerr)); + memset(&src, 0, sizeof(src)); m_nDefaultScaleDenom = 1; } @@ -253,8 +253,7 @@ bool CCodec_JpegDecoder::Create(const uint8_t* src_buf, src.fill_input_buffer = _src_fill_buffer; src.resync_to_restart = _src_resync; m_bJpegTransform = ColorTransform; - if (src_size > 1 && - FXSYS_memcmp(src_buf + src_size - 2, "\xFF\xD9", 2) != 0) { + if (src_size > 1 && memcmp(src_buf + src_size - 2, "\xFF\xD9", 2) != 0) { ((uint8_t*)src_buf)[src_size - 2] = 0xFF; ((uint8_t*)src_buf)[src_size - 1] = 0xD9; } diff --git a/core/fxcodec/codec/fx_codec_jpx_opj.cpp b/core/fxcodec/codec/fx_codec_jpx_opj.cpp index 4fc3d689f1..30e79deeeb 100644 --- a/core/fxcodec/codec/fx_codec_jpx_opj.cpp +++ b/core/fxcodec/codec/fx_codec_jpx_opj.cpp @@ -564,9 +564,9 @@ void color_apply_icc_profile(opj_image_t* image) { image->comps[1] = image->comps[0]; image->comps[2] = image->comps[0]; image->comps[1].data = FX_Alloc(int, (size_t)max); - FXSYS_memset(image->comps[1].data, 0, sizeof(int) * (size_t)max); + memset(image->comps[1].data, 0, sizeof(int) * (size_t)max); image->comps[2].data = FX_Alloc(int, (size_t)max); - FXSYS_memset(image->comps[2].data, 0, sizeof(int) * (size_t)max); + memset(image->comps[2].data, 0, sizeof(int) * (size_t)max); image->numcomps += 2; r = image->comps[0].data; for (int i = 0; i < max; ++i) { @@ -707,7 +707,7 @@ bool CJPX_Decoder::Init(const unsigned char* src_data, uint32_t src_size) { opj_set_default_decoder_parameters(¶meters); parameters.decod_format = 0; parameters.cod_format = 3; - if (FXSYS_memcmp(m_SrcData, szJP2Header, sizeof(szJP2Header)) == 0) { + if (memcmp(m_SrcData, szJP2Header, sizeof(szJP2Header)) == 0) { l_codec = opj_create_decompress(OPJ_CODEC_JP2); parameters.decod_format = 1; } else { @@ -788,7 +788,7 @@ bool CJPX_Decoder::Decode(uint8_t* dest_buf, if (pitch<(int)(image->comps[0].w * 8 * image->numcomps + 31)>> 5 << 2) return false; - FXSYS_memset(dest_buf, 0xff, image->y1 * pitch); + memset(dest_buf, 0xff, image->y1 * pitch); std::vector channel_bufs(image->numcomps); std::vector adjust_comps(image->numcomps); for (uint32_t i = 0; i < image->numcomps; i++) { diff --git a/core/fxcodec/codec/fx_codec_progress.cpp b/core/fxcodec/codec/fx_codec_progress.cpp index e06c592cdc..d8b123b254 100644 --- a/core/fxcodec/codec/fx_codec_progress.cpp +++ b/core/fxcodec/codec/fx_codec_progress.cpp @@ -331,7 +331,7 @@ bool CCodec_ProgressiveDecoder::JpegReadMoreData(CCodec_JpegModule* pJpegModule, } else { uint32_t dwConsume = m_SrcSize - dwAvail; if (dwAvail) { - FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); + memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); } if (dwSize > dwConsume) { dwSize = dwConsume; @@ -593,7 +593,7 @@ bool CCodec_ProgressiveDecoder::GifReadMoreData(ICodec_GifModule* pGifModule, } else { uint32_t dwConsume = m_SrcSize - dwAvail; if (dwAvail) { - FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); + memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); } if (dwSize > dwConsume) { dwSize = dwConsume; @@ -682,7 +682,7 @@ bool CCodec_ProgressiveDecoder::GifInputRecordPositionBuf( case 3: { uint8_t gray = FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb)); - FXSYS_memset(pScanline, gray, sizeX); + memset(pScanline, gray, sizeX); break; } case 8: { @@ -724,11 +724,11 @@ void CCodec_ProgressiveDecoder::GifReadScanline(int32_t row_num, if (m_GifTransIndex != -1 && m_pDeviceBitmap->HasAlpha()) { pal_index = m_GifTransIndex; } - FXSYS_memset(m_pDecodeBuf, pal_index, m_SrcWidth); + memset(m_pDecodeBuf, pal_index, m_SrcWidth); bool bLastPass = (row_num % 2) == 1; int32_t line = row_num + m_GifFrameRect.top; int32_t left = m_GifFrameRect.left; - FXSYS_memcpy(m_pDecodeBuf + left, row_buf, img_width); + memcpy(m_pDecodeBuf + left, row_buf, img_width); int src_top = m_clipBox.top; int src_bottom = m_clipBox.bottom; int des_top = m_startY; @@ -762,7 +762,7 @@ void CCodec_ProgressiveDecoder::GifReadScanline(int32_t row_num, uint8_t* scan_des = (uint8_t*)pDIBitmap->GetScanline(cur_row) + des_ScanOffet; uint32_t size = m_sizeX * des_Bpp; - FXSYS_memmove(scan_des, scan_src, size); + memmove(scan_des, scan_src, size); } } if (bLastPass) @@ -872,7 +872,7 @@ bool CCodec_ProgressiveDecoder::BmpReadMoreData(ICodec_BmpModule* pBmpModule, } else { uint32_t dwConsume = m_SrcSize - dwAvail; if (dwAvail) { - FXSYS_memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); + memmove(m_pSrcBuf, m_pSrcBuf + dwConsume, dwAvail); } if (dwSize > dwConsume) { dwSize = dwConsume; @@ -897,7 +897,7 @@ void CCodec_ProgressiveDecoder::BmpReadScanline(int32_t row_num, uint8_t* row_buf) { CFX_RetainPtr pDIBitmap = m_pDeviceBitmap; ASSERT(pDIBitmap); - FXSYS_memcpy(m_pDecodeBuf, row_buf, m_ScanlineSize); + memcpy(m_pDecodeBuf, row_buf, m_ScanlineSize); int src_top = m_clipBox.top; int src_bottom = m_clipBox.bottom; int des_top = m_startY; @@ -941,7 +941,7 @@ void CCodec_ProgressiveDecoder::ResampleVertBT( uint8_t* scan_des = (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet; uint32_t size = m_sizeX * des_Bpp; - FXSYS_memmove(scan_des, scan_src, size); + memmove(scan_des, scan_src, size); } return; } @@ -1017,7 +1017,7 @@ bool CCodec_ProgressiveDecoder::DetectImageType(FXCODEC_IMAGE_TYPE imageType, } FX_Free(m_pSrcBuf); m_pSrcBuf = FX_Alloc(uint8_t, size); - FXSYS_memset(m_pSrcBuf, 0, size); + memset(m_pSrcBuf, 0, size); m_SrcSize = size; switch (imageType) { case FXCODEC_IMAGE_BMP: { @@ -1059,8 +1059,8 @@ bool CCodec_ProgressiveDecoder::DetectImageType(FXCODEC_IMAGE_TYPE imageType, FX_Free(m_pSrcPalette); if (m_SrcPaletteNumber) { m_pSrcPalette = FX_Alloc(FX_ARGB, m_SrcPaletteNumber); - FXSYS_memcpy(m_pSrcPalette, pPalette, - m_SrcPaletteNumber * sizeof(uint32_t)); + memcpy(m_pSrcPalette, pPalette, + m_SrcPaletteNumber * sizeof(uint32_t)); } else { m_pSrcPalette = nullptr; } @@ -1150,7 +1150,7 @@ bool CCodec_ProgressiveDecoder::DetectImageType(FXCODEC_IMAGE_TYPE imageType, if (m_pSrcBuf && input_size > m_SrcSize) { FX_Free(m_pSrcBuf); m_pSrcBuf = FX_Alloc(uint8_t, input_size); - FXSYS_memset(m_pSrcBuf, 0, input_size); + memset(m_pSrcBuf, 0, input_size); m_SrcSize = input_size; } bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size); @@ -1531,7 +1531,7 @@ void CCodec_ProgressiveDecoder::ReSampleScanline( pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart]; des_g += pixel_weight * src_scan[j]; } - FXSYS_memset(des_scan, (uint8_t)(des_g >> 16), 3); + memset(des_scan, (uint8_t)(des_g >> 16), 3); des_scan += des_Bpp; } break; case 8: { @@ -1664,7 +1664,7 @@ void CCodec_ProgressiveDecoder::ResampleVert( uint8_t* scan_des = (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet; uint32_t size = m_sizeX * des_Bpp; - FXSYS_memmove(scan_des, scan_src, size); + memmove(scan_des, scan_src, size); } } return; @@ -1739,7 +1739,7 @@ void CCodec_ProgressiveDecoder::ResampleVert( uint8_t* scan_des = (uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet; uint32_t size = m_sizeX * des_Bpp; - FXSYS_memmove(scan_des, scan_src, size); + memmove(scan_des, scan_src, size); } } return; @@ -1755,7 +1755,7 @@ void CCodec_ProgressiveDecoder::ResampleVert( uint8_t* scan_des = (uint8_t*)pDeviceBitmap->GetScanline(des_row + i) + des_ScanOffet; uint32_t size = m_sizeX * des_Bpp; - FXSYS_memmove(scan_des, scan_src, size); + memmove(scan_des, scan_src, size); } } } @@ -1912,7 +1912,7 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode( scanline_size = (scanline_size * m_SrcComponents + 3) / 4 * 4; FX_Free(m_pDecodeBuf); m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size); - FXSYS_memset(m_pDecodeBuf, 0, scanline_size); + memset(m_pDecodeBuf, 0, scanline_size); m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0, m_clipBox.Width(), m_bInterpol); m_WeightVert.Calc(m_sizeY, m_clipBox.Height()); @@ -1977,7 +1977,7 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode( int scanline_size = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4; FX_Free(m_pDecodeBuf); m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size); - FXSYS_memset(m_pDecodeBuf, 0, scanline_size); + memset(m_pDecodeBuf, 0, scanline_size); m_WeightHorzOO.Calc(m_sizeX, m_clipBox.Width(), m_bInterpol); m_WeightVert.Calc(m_sizeY, m_clipBox.Height()); m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE; @@ -1996,7 +1996,7 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode( int scanline_size = (m_SrcWidth + 3) / 4 * 4; FX_Free(m_pDecodeBuf); m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size); - FXSYS_memset(m_pDecodeBuf, 0, scanline_size); + memset(m_pDecodeBuf, 0, scanline_size); m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0, m_clipBox.Width(), m_bInterpol); m_WeightVert.Calc(m_sizeY, m_clipBox.Height()); @@ -2027,7 +2027,7 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode( m_ScanlineSize = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4; FX_Free(m_pDecodeBuf); m_pDecodeBuf = FX_Alloc(uint8_t, m_ScanlineSize); - FXSYS_memset(m_pDecodeBuf, 0, m_ScanlineSize); + memset(m_pDecodeBuf, 0, m_ScanlineSize); m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0, m_clipBox.Width(), m_bInterpol); m_WeightVert.Calc(m_sizeY, m_clipBox.Height()); @@ -2102,7 +2102,7 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) { if (m_pSrcBuf && input_size > m_SrcSize) { FX_Free(m_pSrcBuf); m_pSrcBuf = FX_Alloc(uint8_t, input_size); - FXSYS_memset(m_pSrcBuf, 0, input_size); + memset(m_pSrcBuf, 0, input_size); m_SrcSize = input_size; } bool bResult = m_pFile->ReadBlock(m_pSrcBuf, m_offSet, input_size); diff --git a/core/fxcodec/jbig2/JBig2_Define.h b/core/fxcodec/jbig2/JBig2_Define.h index 86df248786..2934de4e9b 100644 --- a/core/fxcodec/jbig2/JBig2_Define.h +++ b/core/fxcodec/jbig2/JBig2_Define.h @@ -9,9 +9,9 @@ #include "core/fxcrt/fx_system.h" -#define JBIG2_memset FXSYS_memset -#define JBIG2_memcmp FXSYS_memcmp -#define JBIG2_memcpy FXSYS_memcpy +#define JBIG2_memset memset +#define JBIG2_memcmp memcmp +#define JBIG2_memcpy memcpy #define JBIG2_OOB 1 struct JBig2RegionInfo { diff --git a/core/fxcodec/lbmp/fx_bmp.cpp b/core/fxcodec/lbmp/fx_bmp.cpp index 73a62d4192..e4fa17dc89 100644 --- a/core/fxcodec/lbmp/fx_bmp.cpp +++ b/core/fxcodec/lbmp/fx_bmp.cpp @@ -47,7 +47,7 @@ void bmp_error(bmp_decompress_struct_p bmp_ptr, const char* err_msg) { } bmp_decompress_struct_p bmp_create_decompress() { bmp_decompress_struct_p bmp_ptr = FX_Alloc(bmp_decompress_struct, 1); - FXSYS_memset(bmp_ptr, 0, sizeof(bmp_decompress_struct)); + memset(bmp_ptr, 0, sizeof(bmp_decompress_struct)); bmp_ptr->decode_status = BMP_D_STATUS_HEADER; bmp_ptr->bmp_header_ptr = FX_Alloc(BmpFileHeader, 1); return bmp_ptr; @@ -233,7 +233,7 @@ int32_t bmp_read_header(bmp_decompress_struct_p bmp_ptr) { } bmp_ptr->out_row_buffer = FX_Alloc(uint8_t, bmp_ptr->out_row_bytes); - FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); + memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_PAL); } if (bmp_ptr->decode_status == BMP_D_STATUS_PAL) { @@ -388,7 +388,7 @@ int32_t bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) { case 8: case 24: case 32: - FXSYS_memcpy(bmp_ptr->out_row_buffer, des_buf, bmp_ptr->src_row_bytes); + memcpy(bmp_ptr->out_row_buffer, des_buf, bmp_ptr->src_row_bytes); break; } row_buf = bmp_ptr->out_row_buffer; @@ -429,7 +429,7 @@ int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) { : (bmp_ptr->height - 1 - bmp_ptr->row_num++), bmp_ptr->out_row_buffer); bmp_ptr->col_num = 0; - FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); + memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA); continue; } @@ -458,7 +458,7 @@ int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) { return 0; } while (bmp_ptr->row_num < bmp_row_num_next) { - FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); + memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); bmp_ptr->bmp_get_row_fn( bmp_ptr, bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ @@ -479,8 +479,8 @@ int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) { bmp_ptr->skip_size = skip_size_org; return 2; } - FXSYS_memcpy(bmp_ptr->out_row_buffer + bmp_ptr->col_num, - second_byte_ptr, *first_byte_ptr); + memcpy(bmp_ptr->out_row_buffer + bmp_ptr->col_num, second_byte_ptr, + *first_byte_ptr); bmp_ptr->col_num += (int32_t)(*first_byte_ptr); } } @@ -495,8 +495,8 @@ int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) { bmp_ptr->skip_size = skip_size_org; return 2; } - FXSYS_memset(bmp_ptr->out_row_buffer + bmp_ptr->col_num, - *second_byte_ptr, *first_byte_ptr); + memset(bmp_ptr->out_row_buffer + bmp_ptr->col_num, *second_byte_ptr, + *first_byte_ptr); bmp_ptr->col_num += (int32_t)(*first_byte_ptr); } } @@ -533,7 +533,7 @@ int32_t bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) { : (bmp_ptr->height - 1 - bmp_ptr->row_num++), bmp_ptr->out_row_buffer); bmp_ptr->col_num = 0; - FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); + memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA); continue; } @@ -562,7 +562,7 @@ int32_t bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) { return 0; } while (bmp_ptr->row_num < bmp_row_num_next) { - FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); + memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes); bmp_ptr->bmp_get_row_fn( bmp_ptr, bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ @@ -669,7 +669,7 @@ bmp_compress_struct_p bmp_create_compress() { bmp_compress_struct_p bmp_ptr; bmp_ptr = FX_Alloc(bmp_compress_struct, 1); if (bmp_ptr) { - FXSYS_memset(bmp_ptr, 0, sizeof(bmp_compress_struct)); + memset(bmp_ptr, 0, sizeof(bmp_compress_struct)); } return bmp_ptr; } @@ -734,7 +734,7 @@ static void bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr, dst_pos = bmp_ptr->file_header.bfOffBits; dst_size += size; dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size); - FXSYS_memset(&dst_buf[dst_pos], 0, size); + memset(&dst_buf[dst_pos], 0, size); uint32_t mask_red; uint32_t mask_green; uint32_t mask_blue; @@ -818,11 +818,10 @@ static void bmp_encode_rgb(bmp_compress_struct_p bmp_ptr, dst_pos = bmp_ptr->file_header.bfOffBits; dst_size += size; dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size); - FXSYS_memset(&dst_buf[dst_pos], 0, size); + memset(&dst_buf[dst_pos], 0, size); for (int32_t row_num = bmp_ptr->src_row - 1; row_num > -1; row_num--) { - FXSYS_memcpy(&dst_buf[dst_pos], - &bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch], - bmp_ptr->src_pitch); + memcpy(&dst_buf[dst_pos], &bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch], + bmp_ptr->src_pitch); dst_pos += dst_pitch; } dst_size = dst_pos; @@ -847,7 +846,7 @@ static void bmp_encode_rle8(bmp_compress_struct_p bmp_ptr, dst_pos = bmp_ptr->file_header.bfOffBits; dst_size += size; dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size); - FXSYS_memset(&dst_buf[dst_pos], 0, size); + memset(&dst_buf[dst_pos], 0, size); for (int32_t row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1;) { index = row_num * bmp_ptr->src_pitch; rle[0] = bmp_rle8_search(&bmp_ptr->src_buf[index + i], size - index - i); @@ -892,7 +891,7 @@ static void bmp_encode_rle4(bmp_compress_struct_p bmp_ptr, dst_pos = bmp_ptr->file_header.bfOffBits; dst_size += size; dst_buf = FX_Realloc(uint8_t, dst_buf, dst_size); - FXSYS_memset(&dst_buf[dst_pos], 0, size); + memset(&dst_buf[dst_pos], 0, size); for (int32_t row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1; rle[1] = 0) { index = row_num * bmp_ptr->src_pitch; @@ -933,10 +932,10 @@ bool bmp_encode_image(bmp_compress_struct_p bmp_ptr, if (!dst_buf) return false; - FXSYS_memset(dst_buf, 0, dst_size); + memset(dst_buf, 0, dst_size); bmp_ptr->file_header.bfOffBits = head_size; if (bmp_ptr->pal_ptr && pal_size) { - FXSYS_memcpy(&dst_buf[head_size], bmp_ptr->pal_ptr, pal_size); + memcpy(&dst_buf[head_size], bmp_ptr->pal_ptr, pal_size); bmp_ptr->file_header.bfOffBits += pal_size; } WriteInfoHeader(&bmp_ptr->info_header, dst_buf); diff --git a/core/fxcodec/lgif/fx_gif.cpp b/core/fxcodec/lgif/fx_gif.cpp index 52cb81bcab..3d5d0e2325 100644 --- a/core/fxcodec/lgif/fx_gif.cpp +++ b/core/fxcodec/lgif/fx_gif.cpp @@ -52,8 +52,8 @@ void CGifLZWDecoder::ClearTable() { code_size_cur = code_size + 1; code_next = code_end + 1; code_old = (uint16_t)-1; - FXSYS_memset(code_table, 0, sizeof(tag_Table) * GIF_MAX_LZW_CODE); - FXSYS_memset(stack, 0, GIF_MAX_LZW_CODE); + memset(code_table, 0, sizeof(tag_Table) * GIF_MAX_LZW_CODE); + memset(stack, 0, GIF_MAX_LZW_CODE); for (uint16_t i = 0; i < code_clear; i++) { code_table[i].suffix = (uint8_t)i; } @@ -90,11 +90,11 @@ int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, uint32_t& des_size) { uint32_t i = 0; if (stack_size != 0) { if (des_size < stack_size) { - FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size); + memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size); stack_size -= (uint16_t)des_size; return 3; } - FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size); + memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size); des_buf += stack_size; i += stack_size; stack_size = 0; @@ -161,13 +161,11 @@ int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, uint32_t& des_size) { } code_old = code; if (i + stack_size > des_size) { - FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], - des_size - i); + memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size - i); stack_size -= (uint16_t)(des_size - i); return 3; } - FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], - stack_size); + memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size); des_buf += stack_size; i += stack_size; stack_size = 0; @@ -192,7 +190,7 @@ static bool gif_grow_buf(uint8_t*& dst_buf, uint32_t& dst_len, uint32_t size) { dst_len = size; dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len); } - FXSYS_memset(dst_buf + len_org, 0, dst_len - len_org); + memset(dst_buf + len_org, 0, dst_len - len_org); return !!dst_buf; } return true; @@ -229,7 +227,7 @@ static inline uint8_t gif_cut_buf(const uint8_t* buf, return buf[offset++]; } CGifLZWEncoder::CGifLZWEncoder() { - FXSYS_memset(this, 0, sizeof(CGifLZWEncoder)); + memset(this, 0, sizeof(CGifLZWEncoder)); } CGifLZWEncoder::~CGifLZWEncoder() {} void CGifLZWEncoder::ClearTable() { @@ -272,9 +270,9 @@ void CGifLZWEncoder::WriteBlock(uint8_t*& dst_buf, longjmp(jmp, 1); } dst_buf[offset++] = index_buf_len; - FXSYS_memcpy(&dst_buf[offset], index_buf, index_buf_len); + memcpy(&dst_buf[offset], index_buf, index_buf_len); offset += index_buf_len; - FXSYS_memset(index_buf, 0, GIF_DATA_BLOCK); + memset(index_buf, 0, GIF_DATA_BLOCK); index_buf_len = 0; } void CGifLZWEncoder::EncodeString(uint32_t index, @@ -391,7 +389,7 @@ void CGifLZWEncoder::Finish(uint8_t*& dst_buf, } gif_decompress_struct_p gif_create_decompress() { gif_decompress_struct_p gif_ptr = FX_Alloc(gif_decompress_struct, 1); - FXSYS_memset(gif_ptr, 0, sizeof(gif_decompress_struct)); + memset(gif_ptr, 0, sizeof(gif_decompress_struct)); gif_ptr->decode_status = GIF_D_STATUS_SIG; gif_ptr->img_ptr_arr_ptr = new std::vector; gif_ptr->cmt_data_ptr = new CFX_ByteString; @@ -439,7 +437,7 @@ void gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) { } gif_compress_struct_p gif_create_compress() { gif_compress_struct_p gif_ptr = FX_Alloc(gif_compress_struct, 1); - FXSYS_memset(gif_ptr, 0, sizeof(gif_compress_struct)); + memset(gif_ptr, 0, sizeof(gif_compress_struct)); gif_ptr->img_encoder_ptr = new CGifLZWEncoder; gif_ptr->header_ptr = FX_Alloc(GifHeader, 1); if (!gif_ptr->header_ptr) { @@ -447,8 +445,8 @@ gif_compress_struct_p gif_create_compress() { FX_Free(gif_ptr); return nullptr; } - FXSYS_memcpy(gif_ptr->header_ptr->signature, GIF_SIGNATURE, 3); - FXSYS_memcpy(gif_ptr->header_ptr->version, "89a", 3); + memcpy(gif_ptr->header_ptr->signature, GIF_SIGNATURE, 3); + memcpy(gif_ptr->header_ptr->version, "89a", 3); gif_ptr->lsd_ptr = FX_Alloc(GifLSD, 1); if (!gif_ptr->lsd_ptr) { FX_Free(gif_ptr->header_ptr); @@ -456,7 +454,7 @@ gif_compress_struct_p gif_create_compress() { FX_Free(gif_ptr); return nullptr; } - FXSYS_memset(gif_ptr->lsd_ptr, 0, sizeof(GifLSD)); + memset(gif_ptr->lsd_ptr, 0, sizeof(GifLSD)); gif_ptr->image_info_ptr = FX_Alloc(GifImageInfo, 1); if (!gif_ptr->image_info_ptr) { FX_Free(gif_ptr->lsd_ptr); @@ -465,7 +463,7 @@ gif_compress_struct_p gif_create_compress() { FX_Free(gif_ptr); return nullptr; } - FXSYS_memset(gif_ptr->image_info_ptr, 0, sizeof(GifImageInfo)); + memset(gif_ptr->image_info_ptr, 0, sizeof(GifImageInfo)); gif_ptr->gce_ptr = FX_Alloc(GifGCE, 1); if (!gif_ptr->gce_ptr) { FX_Free(gif_ptr->image_info_ptr); @@ -485,7 +483,7 @@ gif_compress_struct_p gif_create_compress() { FX_Free(gif_ptr); return nullptr; } - FXSYS_memset(gif_ptr->pte_ptr, 0, sizeof(GifPTE)); + memset(gif_ptr->pte_ptr, 0, sizeof(GifPTE)); gif_ptr->pte_ptr->block_size = 12; return gif_ptr; } @@ -548,7 +546,7 @@ int32_t gif_read_header(gif_decompress_struct_p gif_ptr) { ((GifGF*)&gif_lsd_ptr->global_flag)->color_resolution; FX_Free(gif_ptr->global_pal_ptr); gif_ptr->global_pal_ptr = (GifPalette*)FX_Alloc(uint8_t, global_pal_size); - FXSYS_memcpy(gif_ptr->global_pal_ptr, global_pal_ptr, global_pal_size); + memcpy(gif_ptr->global_pal_ptr, global_pal_ptr, global_pal_size); } gif_ptr->width = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->width); gif_ptr->height = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->height); @@ -690,7 +688,7 @@ int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr) { return 2; } GifPlainText* gif_pt_ptr = FX_Alloc(GifPlainText, 1); - FXSYS_memset(gif_pt_ptr, 0, sizeof(GifPlainText)); + memset(gif_pt_ptr, 0, sizeof(GifPlainText)); gif_takeover_gce_ptr(gif_ptr, &gif_pt_ptr->gce_ptr); gif_pt_ptr->pte_ptr = FX_Alloc(GifPTE, 1); gif_pt_ptr->string_ptr = new CFX_ByteString; @@ -781,7 +779,7 @@ int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) { return 2; GifImage* gif_image_ptr = FX_Alloc(GifImage, 1); - FXSYS_memset(gif_image_ptr, 0, sizeof(GifImage)); + memset(gif_image_ptr, 0, sizeof(GifImage)); gif_image_ptr->image_info_ptr = FX_Alloc(GifImageInfo, 1); gif_image_ptr->image_info_ptr->left = GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->left); @@ -819,8 +817,7 @@ int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) { gif_image_ptr->local_pal_ptr = (GifPalette*)gif_ptr->gif_ask_buf_for_pal_fn(gif_ptr, loc_pal_size); if (gif_image_ptr->local_pal_ptr) { - FXSYS_memcpy((uint8_t*)gif_image_ptr->local_pal_ptr, loc_pal_ptr, - loc_pal_size); + memcpy((uint8_t*)gif_image_ptr->local_pal_ptr, loc_pal_ptr, loc_pal_size); } } uint8_t* code_size_ptr = nullptr; @@ -1065,8 +1062,8 @@ static bool gif_write_header(gif_compress_struct_p gif_ptr, if (!dst_buf) return false; - FXSYS_memset(dst_buf, 0, dst_len); - FXSYS_memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader)); + memset(dst_buf, 0, dst_len); + memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader)); gif_ptr->cur_offset += sizeof(GifHeader); SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width); gif_ptr->cur_offset += 2; @@ -1080,7 +1077,7 @@ static bool gif_write_header(gif_compress_struct_p gif_ptr, if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) { return false; } - FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size); + memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size); gif_ptr->cur_offset += size; } return true; @@ -1101,13 +1098,13 @@ void interlace_buf(const uint8_t* buf, uint32_t pitch, uint32_t height) { j = 3; } temp = FX_Alloc(uint8_t, pitch); - FXSYS_memcpy(temp, &buf[pitch * row], pitch); + memcpy(temp, &buf[pitch * row], pitch); pass[j].push_back(temp); row++; } for (size_t i = 0, row = 0; i < 4; i++) { for (size_t j = 0; j < pass[i].size(); j++, row++) { - FXSYS_memcpy((uint8_t*)&buf[pitch * row], pass[i][j], pitch); + memcpy((uint8_t*)&buf[pitch * row], pass[i][j], pitch); FX_Free(pass[i][j]); } } @@ -1120,13 +1117,13 @@ static void gif_write_block_data(const uint8_t* src_buf, uint32_t src_offset = 0; while (src_len > GIF_DATA_BLOCK) { dst_buf[dst_offset++] = GIF_DATA_BLOCK; - FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], GIF_DATA_BLOCK); + memcpy(&dst_buf[dst_offset], &src_buf[src_offset], GIF_DATA_BLOCK); dst_offset += GIF_DATA_BLOCK; src_offset += GIF_DATA_BLOCK; src_len -= GIF_DATA_BLOCK; } dst_buf[dst_offset++] = (uint8_t)src_len; - FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len); + memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len); dst_offset += src_len; } static bool gif_write_data(gif_compress_struct_p gif_ptr, @@ -1135,7 +1132,7 @@ static bool gif_write_data(gif_compress_struct_p gif_ptr, if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) { return false; } - if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) { + if (memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) { dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION; dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_GCE; gif_ptr->gce_ptr->block_size = 4; @@ -1169,7 +1166,7 @@ static bool gif_write_data(gif_compress_struct_p gif_ptr, if (!gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) { return false; } - FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size); + memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size); gif_ptr->cur_offset += pal_size; } if (lf.interlace) { @@ -1196,7 +1193,7 @@ static bool gif_write_data(gif_compress_struct_p gif_ptr, } gif_ptr->img_encoder_ptr->Finish(dst_buf, dst_len, gif_ptr->cur_offset); dst_buf[gif_ptr->cur_offset++] = 0; - if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 && + if (memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 && gif_ptr->cmt_data_ptr) { dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION; dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_CE; @@ -1204,7 +1201,7 @@ static bool gif_write_data(gif_compress_struct_p gif_ptr, dst_len, gif_ptr->cur_offset); dst_buf[gif_ptr->cur_offset++] = 0; } - if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 && + if (memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 && gif_ptr->pte_data_ptr) { dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION; dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_PTE; diff --git a/core/fxcrt/cfx_bytestring.cpp b/core/fxcrt/cfx_bytestring.cpp index 2d3f0ab46a..cca8ad6be4 100644 --- a/core/fxcrt/cfx_bytestring.cpp +++ b/core/fxcrt/cfx_bytestring.cpp @@ -196,7 +196,7 @@ bool CFX_ByteString::operator==(const char* ptr) const { return m_pData->m_nDataLength == 0; return FXSYS_strlen(ptr) == m_pData->m_nDataLength && - FXSYS_memcmp(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0; + memcmp(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0; } bool CFX_ByteString::operator==(const CFX_ByteStringC& str) const { @@ -204,7 +204,7 @@ bool CFX_ByteString::operator==(const CFX_ByteStringC& str) const { return str.IsEmpty(); return m_pData->m_nDataLength == str.GetLength() && - FXSYS_memcmp(m_pData->m_String, str.c_str(), str.GetLength()) == 0; + memcmp(m_pData->m_String, str.c_str(), str.GetLength()) == 0; } bool CFX_ByteString::operator==(const CFX_ByteString& other) const { @@ -218,16 +218,16 @@ bool CFX_ByteString::operator==(const CFX_ByteString& other) const { return false; return other.m_pData->m_nDataLength == m_pData->m_nDataLength && - FXSYS_memcmp(other.m_pData->m_String, m_pData->m_String, - m_pData->m_nDataLength) == 0; + memcmp(other.m_pData->m_String, m_pData->m_String, + m_pData->m_nDataLength) == 0; } bool CFX_ByteString::operator<(const CFX_ByteString& str) const { if (m_pData == str.m_pData) return false; - int result = FXSYS_memcmp(c_str(), str.c_str(), - std::min(GetLength(), str.GetLength())); + int result = + memcmp(c_str(), str.c_str(), std::min(GetLength(), str.GetLength())); return result < 0 || (result == 0 && GetLength() < str.GetLength()); } @@ -368,8 +368,8 @@ FX_STRSIZE CFX_ByteString::Delete(FX_STRSIZE nIndex, FX_STRSIZE nCount) { } ReallocBeforeWrite(nOldLength); int nCharsToCopy = nOldLength - mLength + 1; - FXSYS_memmove(m_pData->m_String + nIndex, m_pData->m_String + mLength, - nCharsToCopy); + memmove(m_pData->m_String + nIndex, m_pData->m_String + mLength, + nCharsToCopy); m_pData->m_nDataLength = nOldLength - nCount; } return m_pData->m_nDataLength; @@ -472,8 +472,8 @@ FX_STRSIZE CFX_ByteString::Insert(FX_STRSIZE nIndex, char ch) { nNewLength++; ReallocBeforeWrite(nNewLength); - FXSYS_memmove(m_pData->m_String + nIndex + 1, m_pData->m_String + nIndex, - nNewLength - nIndex); + memmove(m_pData->m_String + nIndex + 1, m_pData->m_String + nIndex, + nNewLength - nIndex); m_pData->m_String[nIndex] = ch; m_pData->m_nDataLength = nNewLength; return nNewLength; @@ -630,13 +630,13 @@ FX_STRSIZE CFX_ByteString::Replace(const CFX_ByteStringC& pOld, for (FX_STRSIZE i = 0; i < nCount; i++) { const char* pTarget = FX_strstr(pStart, (FX_STRSIZE)(pEnd - pStart), pOld.c_str(), nSourceLen); - FXSYS_memcpy(pDest, pStart, pTarget - pStart); + memcpy(pDest, pStart, pTarget - pStart); pDest += pTarget - pStart; - FXSYS_memcpy(pDest, pNew.c_str(), pNew.GetLength()); + memcpy(pDest, pNew.c_str(), pNew.GetLength()); pDest += pNew.GetLength(); pStart = pTarget + nSourceLen; } - FXSYS_memcpy(pDest, pStart, pEnd - pStart); + memcpy(pDest, pStart, pEnd - pStart); m_pData.Swap(pNewData); return nCount; } @@ -750,8 +750,8 @@ void CFX_ByteString::TrimLeft(const CFX_ByteStringC& pTargets) { if (pos) { ReallocBeforeWrite(len); FX_STRSIZE nDataLength = len - pos; - FXSYS_memmove(m_pData->m_String, m_pData->m_String + pos, - (nDataLength + 1) * sizeof(char)); + memmove(m_pData->m_String, m_pData->m_String + pos, + (nDataLength + 1) * sizeof(char)); m_pData->m_nDataLength = nDataLength; } } @@ -798,7 +798,7 @@ FX_STRSIZE FX_ftoa(float d, char* buf) { int i = scaled / scale; FXSYS_itoa(i, buf2, 10); FX_STRSIZE len = FXSYS_strlen(buf2); - FXSYS_memcpy(buf + buf_size, buf2, len); + memcpy(buf + buf_size, buf2, len); buf_size += len; int fraction = scaled % scale; if (fraction == 0) { diff --git a/core/fxcrt/cfx_checksumcontext.cpp b/core/fxcrt/cfx_checksumcontext.cpp index 994d18604a..97d0af2d75 100644 --- a/core/fxcrt/cfx_checksumcontext.cpp +++ b/core/fxcrt/cfx_checksumcontext.cpp @@ -129,7 +129,7 @@ void CFX_ChecksumContext::FinishChecksum() { m_pSAXReader.reset(); if (m_pByteContext) { uint8_t digest[20]; - FXSYS_memset(digest, 0, 20); + memset(digest, 0, 20); CRYPT_SHA1Finish(m_pByteContext.get(), digest); int32_t nLen = Base64EncodeA(digest, 20, nullptr); char* pBuffer = m_bsChecksum.GetBuffer(nLen); diff --git a/core/fxcrt/cfx_string_data_template.h b/core/fxcrt/cfx_string_data_template.h index 5167e31b5a..e39f6a5dfd 100644 --- a/core/fxcrt/cfx_string_data_template.h +++ b/core/fxcrt/cfx_string_data_template.h @@ -65,13 +65,13 @@ class CFX_StringDataTemplate { void CopyContents(const CFX_StringDataTemplate& other) { ASSERT(other.m_nDataLength <= m_nAllocLength); - FXSYS_memcpy(m_String, other.m_String, - (other.m_nDataLength + 1) * sizeof(CharType)); + memcpy(m_String, other.m_String, + (other.m_nDataLength + 1) * sizeof(CharType)); } void CopyContents(const CharType* pStr, FX_STRSIZE nLen) { ASSERT(nLen >= 0 && nLen <= m_nAllocLength); - FXSYS_memcpy(m_String, pStr, nLen * sizeof(CharType)); + memcpy(m_String, pStr, nLen * sizeof(CharType)); m_String[nLen] = 0; } @@ -79,7 +79,7 @@ class CFX_StringDataTemplate { const CharType* pStr, FX_STRSIZE nLen) { ASSERT(offset >= 0 && nLen >= 0 && offset + nLen <= m_nAllocLength); - FXSYS_memcpy(m_String + offset, pStr, nLen * sizeof(CharType)); + memcpy(m_String + offset, pStr, nLen * sizeof(CharType)); m_String[offset + nLen] = 0; } diff --git a/core/fxcrt/cfx_widestring.cpp b/core/fxcrt/cfx_widestring.cpp index 2298db68f9..eb6bc66e73 100644 --- a/core/fxcrt/cfx_widestring.cpp +++ b/core/fxcrt/cfx_widestring.cpp @@ -954,8 +954,8 @@ void CFX_WideString::TrimLeft(const CFX_WideStringC& pTargets) { if (pos) { ReallocBeforeWrite(len); FX_STRSIZE nDataLength = len - pos; - FXSYS_memmove(m_pData->m_String, m_pData->m_String + pos, - (nDataLength + 1) * sizeof(wchar_t)); + memmove(m_pData->m_String, m_pData->m_String + pos, + (nDataLength + 1) * sizeof(wchar_t)); m_pData->m_nDataLength = nDataLength; } } diff --git a/core/fxcrt/fx_basic.h b/core/fxcrt/fx_basic.h index 77df71e125..ed2f579579 100644 --- a/core/fxcrt/fx_basic.h +++ b/core/fxcrt/fx_basic.h @@ -184,7 +184,7 @@ class CFX_FixedBufGrow { m_pGrowData.reset(FX_Alloc(DataType, data_size)); return; } - FXSYS_memset(m_FixedData, 0, sizeof(DataType) * FixedSize); + memset(m_FixedData, 0, sizeof(DataType) * FixedSize); } operator DataType*() { return m_pGrowData ? m_pGrowData.get() : m_FixedData; } diff --git a/core/fxcrt/fx_basic_buffer.cpp b/core/fxcrt/fx_basic_buffer.cpp index 341d9013ae..701676f71e 100644 --- a/core/fxcrt/fx_basic_buffer.cpp +++ b/core/fxcrt/fx_basic_buffer.cpp @@ -28,9 +28,8 @@ void CFX_BinaryBuf::Delete(int start_index, int count) { start_index > m_DataSize - count) { return; } - FXSYS_memmove(m_pBuffer.get() + start_index, - m_pBuffer.get() + start_index + count, - m_DataSize - start_index - count); + memmove(m_pBuffer.get() + start_index, m_pBuffer.get() + start_index + count, + m_DataSize - start_index - count); m_DataSize -= count; } @@ -72,9 +71,9 @@ void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size) { ExpandBuf(size); if (pBuf) { - FXSYS_memcpy(m_pBuffer.get() + m_DataSize, pBuf, size); + memcpy(m_pBuffer.get() + m_DataSize, pBuf, size); } else { - FXSYS_memset(m_pBuffer.get() + m_DataSize, 0, size); + memset(m_pBuffer.get() + m_DataSize, 0, size); } m_DataSize += size; } @@ -86,12 +85,12 @@ void CFX_BinaryBuf::InsertBlock(FX_STRSIZE pos, return; ExpandBuf(size); - FXSYS_memmove(m_pBuffer.get() + pos + size, m_pBuffer.get() + pos, - m_DataSize - pos); + memmove(m_pBuffer.get() + pos + size, m_pBuffer.get() + pos, + m_DataSize - pos); if (pBuf) { - FXSYS_memcpy(m_pBuffer.get() + pos, pBuf, size); + memcpy(m_pBuffer.get() + pos, pBuf, size); } else { - FXSYS_memset(m_pBuffer.get() + pos, 0, size); + memset(m_pBuffer.get() + pos, 0, size); } m_DataSize += size; } @@ -254,7 +253,7 @@ int32_t CFX_FileBufferArchive::AppendBlock(const void* pBuf, size_t size) { size_t temp_size = size; while (temp_size) { size_t buf_size = std::min(kBufSize - m_Length, temp_size); - FXSYS_memcpy(m_pBuffer.get() + m_Length, buffer, buf_size); + memcpy(m_pBuffer.get() + m_Length, buffer, buf_size); m_Length += buf_size; if (m_Length == kBufSize) { if (!Flush()) { diff --git a/core/fxcrt/fx_extension.cpp b/core/fxcrt/fx_extension.cpp index f8abff376f..f13922e2da 100644 --- a/core/fxcrt/fx_extension.cpp +++ b/core/fxcrt/fx_extension.cpp @@ -216,7 +216,7 @@ bool CFX_MemoryStream::ReadBlock(void* buffer, m_nCurPos = newPos.ValueOrDie(); if (m_dwFlags & FX_MEMSTREAM_Consecutive) { - FXSYS_memcpy(buffer, m_Blocks[0] + (size_t)offset, size); + memcpy(buffer, m_Blocks[0] + (size_t)offset, size); return true; } size_t nStartBlock = (size_t)offset / m_nGrowSize; @@ -226,7 +226,7 @@ bool CFX_MemoryStream::ReadBlock(void* buffer, if (nRead > size) { nRead = size; } - FXSYS_memcpy(buffer, m_Blocks[(int)nStartBlock] + (size_t)offset, nRead); + memcpy(buffer, m_Blocks[(int)nStartBlock] + (size_t)offset, nRead); buffer = ((uint8_t*)buffer) + nRead; size -= nRead; nStartBlock++; @@ -267,7 +267,7 @@ bool CFX_MemoryStream::WriteBlock(const void* buffer, m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize); } } - FXSYS_memcpy(m_Blocks[0] + (size_t)offset, buffer, size); + memcpy(m_Blocks[0] + (size_t)offset, buffer, size); if (m_nCurSize < m_nCurPos) { m_nCurSize = m_nCurPos; } @@ -291,7 +291,7 @@ bool CFX_MemoryStream::WriteBlock(const void* buffer, if (nWrite > size) { nWrite = size; } - FXSYS_memcpy(m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite); + memcpy(m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite); buffer = ((uint8_t*)buffer) + nWrite; size -= nWrite; nStartBlock++; @@ -597,7 +597,7 @@ void FX_Random_GenerateBase(uint32_t* pBuffer, int32_t iCount) { ::GetSystemTime(&st1); do { ::GetSystemTime(&st2); - } while (FXSYS_memcmp(&st1, &st2, sizeof(SYSTEMTIME)) == 0); + } while (memcmp(&st1, &st2, sizeof(SYSTEMTIME)) == 0); uint32_t dwHash1 = FX_HashCode_GetA(CFX_ByteStringC((uint8_t*)&st1, sizeof(st1)), true); uint32_t dwHash2 = diff --git a/core/fxcrt/fx_system.h b/core/fxcrt/fx_system.h index dcf70451c9..b52cb6adf3 100644 --- a/core/fxcrt/fx_system.h +++ b/core/fxcrt/fx_system.h @@ -171,10 +171,6 @@ extern "C" { #define FXSYS_wcslen(ptr) ((FX_STRSIZE)wcslen(ptr)) #endif // __cplusplus -#define FXSYS_memcmp memcmp -#define FXSYS_memcpy memcpy -#define FXSYS_memmove memmove -#define FXSYS_memset memset #define FXSYS_qsort qsort #define FXSYS_bsearch bsearch diff --git a/core/fxcrt/fxcrt_posix.cpp b/core/fxcrt/fxcrt_posix.cpp index a96f164c7f..562c70c23e 100644 --- a/core/fxcrt/fxcrt_posix.cpp +++ b/core/fxcrt/fxcrt_posix.cpp @@ -66,7 +66,7 @@ FX_FILESIZE CFXCRT_FileAccess_Posix::GetSize() const { return 0; } struct stat s; - FXSYS_memset(&s, 0, sizeof(s)); + memset(&s, 0, sizeof(s)); fstat(m_nFD, &s); return s.st_size; } diff --git a/core/fxcrt/xml/cfx_saxreader.cpp b/core/fxcrt/xml/cfx_saxreader.cpp index 287eaaa5b8..c571e8be96 100644 --- a/core/fxcrt/xml/cfx_saxreader.cpp +++ b/core/fxcrt/xml/cfx_saxreader.cpp @@ -628,14 +628,13 @@ void CFX_SAXReader::SkipNode() { m_iDataLength = m_iDataPos; m_iDataPos = 0; if (m_iDataLength >= 9 && - FXSYS_memcmp(m_pszData, "[CDATA[", 7 * sizeof(uint8_t)) == 0 && - FXSYS_memcmp(m_pszData + m_iDataLength - 2, "]]", - 2 * sizeof(uint8_t)) == 0) { + memcmp(m_pszData, "[CDATA[", 7 * sizeof(uint8_t)) == 0 && + memcmp(m_pszData + m_iDataLength - 2, "]]", + 2 * sizeof(uint8_t)) == 0) { Pop(); m_iDataLength -= 9; m_dwDataOffset += 7; - FXSYS_memmove(m_pszData, m_pszData + 7, - m_iDataLength * sizeof(uint8_t)); + memmove(m_pszData, m_pszData + 7, m_iDataLength * sizeof(uint8_t)); m_bCharData = true; if (m_pHandler) { NotifyData(); diff --git a/core/fxge/android/cfpf_skiafontdescriptor.h b/core/fxge/android/cfpf_skiafontdescriptor.h index 56f8a34fa5..f653050feb 100644 --- a/core/fxge/android/cfpf_skiafontdescriptor.h +++ b/core/fxge/android/cfpf_skiafontdescriptor.h @@ -27,7 +27,7 @@ class CFPF_SkiaFontDescriptor { FX_Free(m_pFamily); int32_t iSize = FXSYS_strlen(pFamily); m_pFamily = FX_Alloc(char, iSize + 1); - FXSYS_memcpy(m_pFamily, pFamily, iSize * sizeof(char)); + memcpy(m_pFamily, pFamily, iSize * sizeof(char)); m_pFamily[iSize] = 0; } char* m_pFamily; diff --git a/core/fxge/android/cfpf_skiafontmgr.cpp b/core/fxge/android/cfpf_skiafontmgr.cpp index 00d989e55c..534f41a548 100644 --- a/core/fxge/android/cfpf_skiafontmgr.cpp +++ b/core/fxge/android/cfpf_skiafontmgr.cpp @@ -371,7 +371,7 @@ FXFT_Face CFPF_SkiaFontMgr::GetFontFace( if (iFaceIndex < 0) return nullptr; FXFT_StreamRec streamRec; - FXSYS_memset(&streamRec, 0, sizeof(FXFT_StreamRec)); + memset(&streamRec, 0, sizeof(FXFT_StreamRec)); streamRec.size = pFileRead->GetSize(); streamRec.descriptor.pointer = static_cast(pFileRead.Get()); streamRec.read = FPF_SkiaStream_Read; diff --git a/core/fxge/android/cfpf_skiapathfont.h b/core/fxge/android/cfpf_skiapathfont.h index f8ddc6c83a..8b7a4f9fb4 100644 --- a/core/fxge/android/cfpf_skiapathfont.h +++ b/core/fxge/android/cfpf_skiapathfont.h @@ -24,7 +24,7 @@ class CFPF_SkiaPathFont : public CFPF_SkiaFontDescriptor { FX_Free(m_pPath); int32_t iSize = FXSYS_strlen(pPath); m_pPath = FX_Alloc(char, iSize + 1); - FXSYS_memcpy(m_pPath, pPath, iSize * sizeof(char)); + memcpy(m_pPath, pPath, iSize * sizeof(char)); m_pPath[iSize] = 0; } char* m_pPath; diff --git a/core/fxge/dib/cfx_bitmapcomposer.cpp b/core/fxge/dib/cfx_bitmapcomposer.cpp index 7124ba9d46..8dd87b1def 100644 --- a/core/fxge/dib/cfx_bitmapcomposer.cpp +++ b/core/fxge/dib/cfx_bitmapcomposer.cpp @@ -95,7 +95,7 @@ void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan, m_pAddClipScan[i] = clip_scan[i] * m_BitmapAlpha / 255; } } else { - FXSYS_memset(m_pAddClipScan, m_BitmapAlpha, dest_width); + memset(m_pAddClipScan, m_BitmapAlpha, dest_width); } clip_scan = m_pAddClipScan; } diff --git a/core/fxge/dib/cfx_bitmapstorer.cpp b/core/fxge/dib/cfx_bitmapstorer.cpp index ac876b16b7..4e1cb3bc38 100644 --- a/core/fxge/dib/cfx_bitmapstorer.cpp +++ b/core/fxge/dib/cfx_bitmapstorer.cpp @@ -32,11 +32,11 @@ void CFX_BitmapStorer::ComposeScanline(int line, ? const_cast(m_pBitmap->m_pAlphaMask->GetScanline(line)) : nullptr; if (dest_buf) - FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch()); + memcpy(dest_buf, scanline, m_pBitmap->GetPitch()); if (dest_alpha_buf) { - FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha, - m_pBitmap->m_pAlphaMask->GetPitch()); + memcpy(dest_alpha_buf, scan_extra_alpha, + m_pBitmap->m_pAlphaMask->GetPitch()); } } diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp index 0adc088b53..b97917dba7 100644 --- a/core/fxge/dib/cfx_dibitmap.cpp +++ b/core/fxge/dib/cfx_dibitmap.cpp @@ -90,7 +90,7 @@ bool CFX_DIBitmap::Copy(const CFX_RetainPtr& pSrc) { SetPalette(pSrc->GetPalette()); SetAlphaMask(pSrc->m_pAlphaMask); for (int row = 0; row < pSrc->GetHeight(); row++) - FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch); + memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch); return true; } @@ -130,20 +130,19 @@ void CFX_DIBitmap::Clear(uint32_t color) { } switch (GetFormat()) { case FXDIB_1bppMask: - FXSYS_memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0, - m_Pitch * m_Height); + memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height); break; case FXDIB_1bppRgb: { int index = FindPalette(color); - FXSYS_memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height); + memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height); break; } case FXDIB_8bppMask: - FXSYS_memset(m_pBuffer, color >> 24, m_Pitch * m_Height); + memset(m_pBuffer, color >> 24, m_Pitch * m_Height); break; case FXDIB_8bppRgb: { int index = FindPalette(color); - FXSYS_memset(m_pBuffer, index, m_Pitch * m_Height); + memset(m_pBuffer, index, m_Pitch * m_Height); break; } case FXDIB_Rgb: @@ -151,7 +150,7 @@ void CFX_DIBitmap::Clear(uint32_t color) { int a, r, g, b; ArgbDecode(color, a, r, g, b); if (r == g && g == b) { - FXSYS_memset(m_pBuffer, r, m_Pitch * m_Height); + memset(m_pBuffer, r, m_Pitch * m_Height); } else { int byte_pos = 0; for (int col = 0; col < m_Width; col++) { @@ -160,7 +159,7 @@ void CFX_DIBitmap::Clear(uint32_t color) { m_pBuffer[byte_pos++] = r; } for (int row = 1; row < m_Height; row++) { - FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch); + memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch); } } break; @@ -177,7 +176,7 @@ void CFX_DIBitmap::Clear(uint32_t color) { ((uint32_t*)m_pBuffer)[i] = color; } for (int row = 1; row < m_Height; row++) { - FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch); + memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch); } break; } @@ -227,7 +226,7 @@ bool CFX_DIBitmap::TransferBitmap( m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp; const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp; - FXSYS_memcpy(dest_scan, src_scan, width * Bpp); + memcpy(dest_scan, src_scan, width * Bpp); } } } else { @@ -336,10 +335,10 @@ bool CFX_DIBitmap::TransferMask(int dest_left, for (int col = 0; col < width; col++) { int src_bitpos = src_left + col; if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) { - FXSYS_memcpy(dest_color_pos, color_p, comps); + memcpy(dest_color_pos, color_p, comps); *dest_alpha_pos = 0xff; } else { - FXSYS_memset(dest_color_pos, 0, comps); + memset(dest_color_pos, 0, comps); *dest_alpha_pos = 0; } dest_color_pos += comps; @@ -348,7 +347,7 @@ bool CFX_DIBitmap::TransferMask(int dest_left, } else { src_scan += src_left; for (int col = 0; col < width; col++) { - FXSYS_memcpy(dest_color_pos, color_p, comps); + memcpy(dest_color_pos, color_p, comps); dest_color_pos += comps; *dest_alpha_pos++ = (alpha * (*src_scan++) / 255); } @@ -505,12 +504,12 @@ bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) { } int Bpp = GetBPP() / 8; if (Bpp == 1) { - FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch); + memset(m_pBuffer, value, m_Height * m_Pitch); return true; } if (destChannel == FXDIB_Alpha && m_pAlphaMask) { - FXSYS_memset(m_pAlphaMask->GetBuffer(), value, - m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch()); + memset(m_pAlphaMask->GetBuffer(), value, + m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch()); return true; } for (int row = 0; row < m_Height; row++) { @@ -601,7 +600,7 @@ bool CFX_DIBitmap::GetGrayData(void* pIccTransform) { if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) return false; - FXSYS_memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height); + memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height); for (int row = 0; row < m_Height; row++) { uint8_t* src_pos = m_pBuffer + row * m_Pitch; uint8_t* dest_pos = (uint8_t*)pMask->GetScanline(row); @@ -1230,7 +1229,7 @@ bool CFX_DIBitmap::CompositeRect(int left, for (int row = rect.top; row < rect.bottom; row++) { uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left; if (src_alpha == 255) { - FXSYS_memset(dest_scan, gray, width); + memset(dest_scan, gray, width); } else { for (int col = 0; col < width; col++) { *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); @@ -1262,7 +1261,7 @@ bool CFX_DIBitmap::CompositeRect(int left, uint8_t left_flag = *dest_scan_top & (255 << (8 - left_shift)); uint8_t right_flag = *dest_scan_top_r & (255 >> right_shift); if (new_width) { - FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, new_width - 1); + memset(dest_scan_top + 1, index ? 255 : 0, new_width - 1); if (!index) { *dest_scan_top &= left_flag; *dest_scan_top_r &= right_flag; @@ -1310,7 +1309,7 @@ bool CFX_DIBitmap::CompositeRect(int left, m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left : nullptr; if (dest_scan_alpha) { - FXSYS_memset(dest_scan_alpha, 0xff, width); + memset(dest_scan_alpha, 0xff, width); } if (Bpp == 4) { uint32_t* scan = (uint32_t*)dest_scan; @@ -1357,7 +1356,7 @@ bool CFX_DIBitmap::CompositeRect(int left, uint8_t back_alpha = *dest_scan_alpha; if (back_alpha == 0) { *dest_scan_alpha++ = src_alpha; - FXSYS_memcpy(dest_scan, color_p, Bpp); + memcpy(dest_scan, color_p, Bpp); dest_scan += Bpp; continue; } @@ -1417,7 +1416,7 @@ bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) { } CFX_RetainPtr pAlphaMask; if (dest_format == FXDIB_Argb) { - FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4); + memset(dest_buf, 0xff, dest_pitch * m_Height + 4); if (m_pAlphaMask) { for (int row = 0; row < m_Height; row++) { uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3; diff --git a/core/fxge/dib/cfx_dibsource.cpp b/core/fxge/dib/cfx_dibsource.cpp index 4b76b02ee7..1a11632759 100644 --- a/core/fxge/dib/cfx_dibsource.cpp +++ b/core/fxge/dib/cfx_dibsource.cpp @@ -63,7 +63,7 @@ CFX_RetainPtr CFX_DIBSource::Clone(const FX_RECT* pClip) const { for (int row = rect.top; row < rect.bottom; row++) { const uint8_t* src_scan = GetScanline(row) + rect.left * m_bpp / 8; uint8_t* dest_scan = (uint8_t*)pNewBitmap->GetScanline(row - rect.top); - FXSYS_memcpy(dest_scan, src_scan, copy_len); + memcpy(dest_scan, src_scan, copy_len); } } return pNewBitmap; @@ -103,8 +103,8 @@ bool CFX_DIBSource::BuildAlphaMask() { m_pAlphaMask = nullptr; return false; } - FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff, - m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch()); + memset(m_pAlphaMask->GetBuffer(), 0xff, + m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch()); return true; } @@ -203,7 +203,7 @@ void CFX_DIBSource::SetPalette(const uint32_t* pSrc) { if (!m_pPalette) m_pPalette.reset(FX_Alloc(uint32_t, pal_size)); pal_size = std::min(pal_size, kPaletteSize); - FXSYS_memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t)); + memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t)); } void CFX_DIBSource::GetPalette(uint32_t* pal, int alpha) const { @@ -272,9 +272,9 @@ bool CFX_DIBSource::SetAlphaMask(const CFX_RetainPtr& pAlphaMask, return false; } for (int row = 0; row < m_Height; row++) { - FXSYS_memcpy(const_cast(m_pAlphaMask->GetScanline(row)), - pAlphaMask->GetScanline(row + rect.top) + rect.left, - m_pAlphaMask->m_Pitch); + memcpy(const_cast(m_pAlphaMask->GetScanline(row)), + pAlphaMask->GetScanline(row + rect.top) + rect.left, + m_pAlphaMask->m_Pitch); } return true; } @@ -293,11 +293,11 @@ CFX_RetainPtr CFX_DIBSource::FlipImage(bool bXFlip, uint8_t* dest_scan = pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row); if (!bXFlip) { - FXSYS_memcpy(dest_scan, src_scan, m_Pitch); + memcpy(dest_scan, src_scan, m_Pitch); continue; } if (m_bpp == 1) { - FXSYS_memset(dest_scan, 0, m_Pitch); + memset(dest_scan, 0, m_Pitch); for (int col = 0; col < m_Width; col++) if (src_scan[col / 8] & (1 << (7 - col % 8))) { int dest_col = m_Width - col - 1; @@ -337,7 +337,7 @@ CFX_RetainPtr CFX_DIBSource::FlipImage(bool bXFlip, uint8_t* dest_scan = pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row); if (!bXFlip) { - FXSYS_memcpy(dest_scan, src_scan, dest_pitch); + memcpy(dest_scan, src_scan, dest_pitch); continue; } dest_scan += (m_Width - 1); @@ -418,7 +418,7 @@ CFX_RetainPtr CFX_DIBSource::SwapXY( int col_start = bYFlip ? m_Width - dest_clip.bottom : dest_clip.top; int col_end = bYFlip ? m_Width - dest_clip.top : dest_clip.bottom; if (GetBPP() == 1) { - FXSYS_memset(dest_buf, 0xff, dest_pitch * result_height); + memset(dest_buf, 0xff, dest_pitch * result_height); for (int row = row_start; row < row_end; row++) { const uint8_t* src_scan = GetScanline(row); int dest_col = (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp index 1e2a282c1f..ff7dd06c3e 100644 --- a/core/fxge/dib/cfx_scanlinecompositor.cpp +++ b/core/fxge/dib/cfx_scanlinecompositor.cpp @@ -198,7 +198,7 @@ void CompositeRow_Rgb2Mask(uint8_t* dest_scan, int width, const uint8_t* clip_scan) { if (!clip_scan) { - FXSYS_memset(dest_scan, 0xff, width); + memset(dest_scan, 0xff, width); return; } for (int i = 0; i < width; ++i) { @@ -872,7 +872,7 @@ void CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan, int dest_Bpp, int src_Bpp) { if (dest_Bpp == src_Bpp) { - FXSYS_memcpy(dest_scan, src_scan, width * dest_Bpp); + memcpy(dest_scan, src_scan, width * dest_Bpp); return; } for (int col = 0; col < width; col++) { @@ -3386,7 +3386,7 @@ void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format, int palsize = 1 << (src_format & 0xff); pDestPalette = FX_Alloc(uint32_t, palsize); if (isDstCmyk == isSrcCmyk) { - FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t)); + memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t)); } else { for (int i = 0; i < palsize; i++) { FX_CMYK cmyk = pSrcPalette[i]; diff --git a/core/fxge/dib/fx_dib_convert.cpp b/core/fxge/dib/fx_dib_convert.cpp index d3cff24326..17eae7e3af 100644 --- a/core/fxge/dib/fx_dib_convert.cpp +++ b/core/fxge/dib/fx_dib_convert.cpp @@ -155,7 +155,7 @@ bool ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, reset_gray = 0x00; for (int row = 0; row < height; row++) { uint8_t* dest_scan = dest_buf + row * dest_pitch; - FXSYS_memset(dest_scan, reset_gray, width); + memset(dest_scan, reset_gray, width); const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row); for (int col = src_left; col < src_left + width; col++) { if (src_scan[col / 8] & (1 << (7 - col % 8))) { @@ -177,7 +177,7 @@ bool ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, for (int row = 0; row < height; row++) { uint8_t* dest_scan = dest_buf + row * dest_pitch; const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left; - FXSYS_memcpy(dest_scan, src_scan, width); + memcpy(dest_scan, src_scan, width); } return true; } @@ -217,7 +217,7 @@ bool ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, for (int row = 0; row < height; row++) { uint8_t* dest_scan = dest_buf + row * dest_pitch; - FXSYS_memset(dest_scan, gray[0], width); + memset(dest_scan, gray[0], width); const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row); for (int col = src_left; col < src_left + width; col++) { if (src_scan[col / 8] & (1 << (7 - col % 8))) { @@ -313,7 +313,7 @@ void ConvertBuffer_IndexCopy(uint8_t* dest_buf, if (pSrcBitmap->GetBPP() == 1) { for (int row = 0; row < height; row++) { uint8_t* dest_scan = dest_buf + row * dest_pitch; - FXSYS_memset(dest_scan, 0, width); + memset(dest_scan, 0, width); const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row); for (int col = src_left; col < src_left + width; col++) { if (src_scan[col / 8] & (1 << (7 - col % 8))) { @@ -327,7 +327,7 @@ void ConvertBuffer_IndexCopy(uint8_t* dest_buf, uint8_t* dest_scan = dest_buf + row * dest_pitch; const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left; - FXSYS_memcpy(dest_scan, src_scan, width); + memcpy(dest_scan, src_scan, width); } } } @@ -355,7 +355,7 @@ bool ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, dst_plt[i] = FXARGB_MAKE(0xff, r, g, b); } } else { - FXSYS_memcpy(dst_plt, src_plt, plt_size * 4); + memcpy(dst_plt, src_plt, plt_size * 4); } return true; } @@ -418,7 +418,7 @@ bool ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, } } } - FXSYS_memcpy(dst_plt, pPalette, sizeof(uint32_t) * 256); + memcpy(dst_plt, pPalette, sizeof(uint32_t) * 256); return true; } @@ -587,7 +587,7 @@ bool ConvertBuffer_24bppRgb2Rgb24( uint8_t* dest_scan = dest_buf + row * dest_pitch; const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 3; - FXSYS_memcpy(dest_scan, src_scan, width * 3); + memcpy(dest_scan, src_scan, width * 3); } return true; } diff --git a/core/fxge/dib/fx_dib_engine.cpp b/core/fxge/dib/fx_dib_engine.cpp index 9a5a7c1351..a232142681 100644 --- a/core/fxge/dib/fx_dib_engine.cpp +++ b/core/fxge/dib/fx_dib_engine.cpp @@ -274,7 +274,7 @@ CStretchEngine::CStretchEngine(IFX_ScanlineComposer* pDestBitmap, return; } if (dest_format == FXDIB_Rgb32) { - FXSYS_memset(m_pDestScanline, 255, size); + memset(m_pDestScanline, 255, size); } m_InterPitch = (m_DestClip.Width() * m_DestBpp + 31) / 32 * 4; m_ExtraMaskPitch = (m_DestClip.Width() * 8 + 31) / 32 * 4; diff --git a/core/fxge/ge/cfx_facecache.cpp b/core/fxge/ge/cfx_facecache.cpp index 0e9e40135a..69be8a1535 100644 --- a/core/fxge/ge/cfx_facecache.cpp +++ b/core/fxge/ge/cfx_facecache.cpp @@ -57,8 +57,8 @@ void ContrastAdjust(uint8_t* pDataIn, if (temp == 0 || temp == 255) { int rowbytes = std::min(abs(nSrcRowBytes), nDstRowBytes); for (row = 0; row < nHeight; row++) { - FXSYS_memcpy(pDataOut + row * nDstRowBytes, pDataIn + row * nSrcRowBytes, - rowbytes); + memcpy(pDataOut + row * nDstRowBytes, pDataIn + row * nSrcRowBytes, + rowbytes); } return; } @@ -206,14 +206,14 @@ CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(const CFX_Font* pFont, } } } else { - FXSYS_memset(pDestBuf, 0, dest_pitch * bmheight); + memset(pDestBuf, 0, dest_pitch * bmheight); if (anti_alias == FXFT_RENDER_MODE_MONO && FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) == FXFT_PIXEL_MODE_MONO) { int rowbytes = abs(src_pitch) > dest_pitch ? dest_pitch : abs(src_pitch); for (int row = 0; row < bmheight; row++) { - FXSYS_memcpy(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, - rowbytes); + memcpy(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, + rowbytes); } } else { ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch, diff --git a/core/fxge/ge/cfx_fontmapper.cpp b/core/fxge/ge/cfx_fontmapper.cpp index e04e581434..9b2e1aa583 100644 --- a/core/fxge/ge/cfx_fontmapper.cpp +++ b/core/fxge/ge/cfx_fontmapper.cpp @@ -280,7 +280,7 @@ CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr) : m_bListLoaded(false), m_pFontMgr(mgr) { m_MMFaces[0] = nullptr; m_MMFaces[1] = nullptr; - FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces)); + memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces)); } CFX_FontMapper::~CFX_FontMapper() { diff --git a/core/fxge/ge/cfx_graphstatedata.cpp b/core/fxge/ge/cfx_graphstatedata.cpp index 8c5508f2f2..82fede176a 100644 --- a/core/fxge/ge/cfx_graphstatedata.cpp +++ b/core/fxge/ge/cfx_graphstatedata.cpp @@ -34,7 +34,7 @@ void CFX_GraphStateData::Copy(const CFX_GraphStateData& src) { m_LineWidth = src.m_LineWidth; if (m_DashCount) { m_DashArray = FX_Alloc(float, m_DashCount); - FXSYS_memcpy(m_DashArray, src.m_DashArray, m_DashCount * sizeof(float)); + memcpy(m_DashArray, src.m_DashArray, m_DashCount * sizeof(float)); } } diff --git a/core/fxge/skia/fx_skia_device.cpp b/core/fxge/skia/fx_skia_device.cpp index 1dc8ab2c7b..81ca95fbe8 100644 --- a/core/fxge/skia/fx_skia_device.cpp +++ b/core/fxge/skia/fx_skia_device.cpp @@ -1753,11 +1753,11 @@ bool CFX_SkiaDeviceDriver::DrawShading(const CPDF_ShadingPattern* pPattern, SkPoint tempCubics[4]; for (int i = 0; i < (int)SK_ARRAY_COUNT(tempCubics); i++) tempCubics[i] = cubics[(flag * 3 + i) % 12]; - FXSYS_memcpy(cubics, tempCubics, sizeof(tempCubics)); + memcpy(cubics, tempCubics, sizeof(tempCubics)); SkColor tempColors[2]; tempColors[0] = colors[flag]; tempColors[1] = colors[(flag + 1) % 4]; - FXSYS_memcpy(colors, tempColors, sizeof(tempColors)); + memcpy(colors, tempColors, sizeof(tempColors)); } for (int i = iStartPoint; i < (int)SK_ARRAY_COUNT(cubics); i++) { CFX_PointF point = stream.ReadCoords(); diff --git a/core/fxge/win32/cfx_psrenderer.cpp b/core/fxge/win32/cfx_psrenderer.cpp index 40c643ea14..46af33710c 100644 --- a/core/fxge/win32/cfx_psrenderer.cpp +++ b/core/fxge/win32/cfx_psrenderer.cpp @@ -260,8 +260,8 @@ void CFX_PSRenderer::SetGraphState(const CFX_GraphStateData* pGraphState) { } if (!m_bGraphStateSet || m_CurGraphState.m_DashCount != pGraphState->m_DashCount || - FXSYS_memcmp(m_CurGraphState.m_DashArray, pGraphState->m_DashArray, - sizeof(float) * m_CurGraphState.m_DashCount)) { + memcmp(m_CurGraphState.m_DashArray, pGraphState->m_DashArray, + sizeof(float) * m_CurGraphState.m_DashCount)) { buf << "["; for (int i = 0; i < pGraphState->m_DashCount; ++i) { buf << pGraphState->m_DashArray[i] << " "; @@ -392,7 +392,7 @@ bool CFX_PSRenderer::DrawDIBits(const CFX_RetainPtr& pSource, uint8_t* src_buf = FX_Alloc(uint8_t, src_size); for (int row = 0; row < height; row++) { const uint8_t* src_scan = pSource->GetScanline(row); - FXSYS_memcpy(src_buf + row * pitch, src_scan, pitch); + memcpy(src_buf + row * pitch, src_scan, pitch); } std::unique_ptr output_buf; uint32_t output_size; @@ -471,7 +471,7 @@ bool CFX_PSRenderer::DrawDIBits(const CFX_RetainPtr& pSource, src_scan += 3; } } else { - FXSYS_memcpy(dest_scan, src_scan, src_pitch); + memcpy(dest_scan, src_scan, src_pitch); } } uint8_t* compressed_buf; diff --git a/core/fxge/win32/cpsoutput.cpp b/core/fxge/win32/cpsoutput.cpp index 24df15226b..7a8434ec33 100644 --- a/core/fxge/win32/cpsoutput.cpp +++ b/core/fxge/win32/cpsoutput.cpp @@ -29,7 +29,7 @@ void CPSOutput::OutputPS(const char* str, int len) { char buffer[1026]; int send_len = std::min(len, 1024); *(reinterpret_cast(buffer)) = send_len; - FXSYS_memcpy(buffer + 2, str + sent_len, send_len); + memcpy(buffer + 2, str + sent_len, send_len); // TODO(thestig/rbpotter): Do PASSTHROUGH for non-Chromium usage. // ExtEscape(m_hDC, PASSTHROUGH, send_len + 2, buffer, 0, nullptr); diff --git a/core/fxge/win32/fx_win32_device.cpp b/core/fxge/win32/fx_win32_device.cpp index de17c0d0b5..a27ac6fbd2 100644 --- a/core/fxge/win32/fx_win32_device.cpp +++ b/core/fxge/win32/fx_win32_device.cpp @@ -446,7 +446,7 @@ void CFX_Win32FontInfo::AddInstalledFont(const LOGFONTA* plf, bool CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) { m_pMapper = pMapper; LOGFONTA lf; - FXSYS_memset(&lf, 0, sizeof(LOGFONTA)); + memset(&lf, 0, sizeof(LOGFONTA)); lf.lfCharSet = FXFONT_DEFAULT_CHARSET; lf.lfFaceName[0] = 0; lf.lfPitchAndFamily = 0; @@ -879,7 +879,7 @@ bool CGdiDeviceDriver::GDI_StretchBitMask( BITMAPINFOHEADER bmiHeader; uint32_t bmiColors[2]; } bmi; - FXSYS_memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER)); + memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER)); bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmi.bmiHeader.biBitCount = 1; bmi.bmiHeader.biCompression = BI_RGB; @@ -1180,7 +1180,7 @@ bool CGdiDisplayDriver::GetDIBits(const CFX_RetainPtr& pBitmap, BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY); SelectObject(hDCMemory, holdbmp); BITMAPINFO bmi; - FXSYS_memset(&bmi, 0, sizeof bmi); + memset(&bmi, 0, sizeof bmi); bmi.bmiHeader.biSize = sizeof bmi.bmiHeader; bmi.bmiHeader.biBitCount = pBitmap->GetBPP(); bmi.bmiHeader.biHeight = -height; diff --git a/core/fxge/win32/fx_win32_dib.cpp b/core/fxge/win32/fx_win32_dib.cpp index 9815457bbd..f2c47265f7 100644 --- a/core/fxge/win32/fx_win32_dib.cpp +++ b/core/fxge/win32/fx_win32_dib.cpp @@ -19,7 +19,7 @@ CFX_ByteString CFX_WindowsDIB::GetBitmapInfo( len += sizeof(DWORD) * (int)(1 << pBitmap->GetBPP()); } BITMAPINFOHEADER* pbmih = (BITMAPINFOHEADER*)result.GetBuffer(len); - FXSYS_memset(pbmih, 0, sizeof(BITMAPINFOHEADER)); + memset(pbmih, 0, sizeof(BITMAPINFOHEADER)); pbmih->biSize = sizeof(BITMAPINFOHEADER); pbmih->biBitCount = pBitmap->GetBPP(); pbmih->biCompression = BI_RGB; @@ -70,15 +70,15 @@ CFX_RetainPtr _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, if (!pBitmap->Create(width, height, format)) return nullptr; - FXSYS_memcpy(pBitmap->GetBuffer(), pData, pitch * height); + memcpy(pBitmap->GetBuffer(), pData, pitch * height); if (bBottomUp) { uint8_t* temp_buf = FX_Alloc(uint8_t, pitch); int top = 0, bottom = height - 1; while (top < bottom) { - FXSYS_memcpy(temp_buf, pBitmap->GetBuffer() + top * pitch, pitch); - FXSYS_memcpy(pBitmap->GetBuffer() + top * pitch, - pBitmap->GetBuffer() + bottom * pitch, pitch); - FXSYS_memcpy(pBitmap->GetBuffer() + bottom * pitch, temp_buf, pitch); + memcpy(temp_buf, pBitmap->GetBuffer() + top * pitch, pitch); + memcpy(pBitmap->GetBuffer() + top * pitch, + pBitmap->GetBuffer() + bottom * pitch, pitch); + memcpy(pBitmap->GetBuffer() + bottom * pitch, temp_buf, pitch); top++; bottom--; } @@ -189,7 +189,7 @@ CFX_RetainPtr CFX_WindowsDIB::LoadDIBitmap( CFX_WindowsDIB::CFX_WindowsDIB(HDC hDC, int width, int height) { Create(width, height, FXDIB_Rgb, (uint8_t*)1); BITMAPINFOHEADER bmih; - FXSYS_memset(&bmih, 0, sizeof bmih); + memset(&bmih, 0, sizeof bmih); bmih.biSize = sizeof bmih; bmih.biBitCount = 24; bmih.biHeight = -height; diff --git a/core/fxge/win32/fx_win32_gdipext.cpp b/core/fxge/win32/fx_win32_gdipext.cpp index 41f9ba55ad..6a3527f393 100644 --- a/core/fxge/win32/fx_win32_gdipext.cpp +++ b/core/fxge/win32/fx_win32_gdipext.cpp @@ -1297,7 +1297,7 @@ class GpStream final : public IStream { } bytes_left = m_InterStream.GetLength() - m_ReadPos; bytes_out = std::min(pdfium::base::checked_cast(cb), bytes_left); - FXSYS_memcpy(Output, m_InterStream.GetBuffer() + m_ReadPos, bytes_out); + memcpy(Output, m_InterStream.GetBuffer() + m_ReadPos, bytes_out); m_ReadPos += (int32_t)bytes_out; if (pcbRead) { *pcbRead = (ULONG)bytes_out; @@ -1508,11 +1508,11 @@ CFX_RetainPtr CGdiplusExt::LoadDIBitmap(WINDIB_Open_Args_ args) { int dest_pitch = (width * pInfo->pbmi->bmiHeader.biBitCount + 31) / 32 * 4; LPBYTE pData = FX_Alloc2D(BYTE, dest_pitch, height); if (dest_pitch == pInfo->Stride) { - FXSYS_memcpy(pData, pInfo->pScan0, dest_pitch * height); + memcpy(pData, pInfo->pScan0, dest_pitch * height); } else { for (int i = 0; i < height; i++) { - FXSYS_memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i, - dest_pitch); + memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i, + dest_pitch); } } CFX_RetainPtr pDIBitmap = _FX_WindowsDIB_LoadFromBuf( -- cgit v1.2.3