Kill FXSYS_mem{cpy,cmp,set.move}{32,8}.
At one point in time, it may have made sense to indicate the
expected alignment of the memory you're about to copy, but that
was last century. The compiler will take care of it just fine.
I stopped short of removing the FXSYS_ wrapper macros entirely.
R=thestig@chromium.org
Review URL: https://codereview.chromium.org/1179693003.
diff --git a/core/include/fxcrt/fx_basic.h b/core/include/fxcrt/fx_basic.h
index df36c26..3ae8b10 100644
--- a/core/include/fxcrt/fx_basic.h
+++ b/core/include/fxcrt/fx_basic.h
@@ -744,7 +744,7 @@
if (data_size > FixedSize) {
m_pData = FX_Alloc(DataType, data_size);
} else {
- FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
+ FXSYS_memset(m_Data, 0, sizeof(DataType)*FixedSize);
}
}
void SetDataSize(int data_size)
@@ -756,7 +756,7 @@
if (data_size > FixedSize) {
m_pData = FX_Alloc(DataType, data_size);
} else {
- FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
+ FXSYS_memset(m_Data, 0, sizeof(DataType)*FixedSize);
}
}
~CFX_FixedBufGrow()
diff --git a/core/include/fxcrt/fx_string.h b/core/include/fxcrt/fx_string.h
index f02cce9..8d73555 100644
--- a/core/include/fxcrt/fx_string.h
+++ b/core/include/fxcrt/fx_string.h
@@ -88,11 +88,11 @@
bool operator== (const char* ptr) const {
return FXSYS_strlen(ptr) == m_Length &&
- FXSYS_memcmp32(ptr, m_Ptr, m_Length) == 0;
+ FXSYS_memcmp(ptr, m_Ptr, m_Length) == 0;
}
bool operator== (const CFX_ByteStringC& other) const {
return other.m_Length == m_Length &&
- FXSYS_memcmp32(other.m_Ptr, m_Ptr, m_Length) == 0;
+ FXSYS_memcmp(other.m_Ptr, m_Ptr, m_Length) == 0;
}
bool operator!= (const char* ptr) const { return !(*this == ptr); }
bool operator!= (const CFX_ByteStringC& other) const {
@@ -254,7 +254,7 @@
bool operator< (const CFX_ByteString& str) const
{
- int result = FXSYS_memcmp32(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
+ int result = FXSYS_memcmp(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
return result < 0 || (result == 0 && GetLength() < str.GetLength());
}
diff --git a/core/include/fxcrt/fx_system.h b/core/include/fxcrt/fx_system.h
index ec6d629..8bc2b4a 100644
--- a/core/include/fxcrt/fx_system.h
+++ b/core/include/fxcrt/fx_system.h
@@ -214,11 +214,6 @@
wchar_t* FXSYS_wcsupr(wchar_t* str);
#endif // _FXM_PLATFORM == _FXM_PLATFORM_WINDOWS_
-#define FXSYS_memcpy32 FXSYS_memcpy
-#define FXSYS_memcmp32 FXSYS_memcmp
-#define FXSYS_memset32 FXSYS_memset
-#define FXSYS_memset8 FXSYS_memset
-#define FXSYS_memmove32 FXSYS_memmove
#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
#define FXSYS_pow(a, b) (FX_FLOAT)powf(a, b)
#else
diff --git a/core/src/fdrm/crypto/fx_crypt.cpp b/core/src/fdrm/crypto/fx_crypt.cpp
index f6b3148..8413649 100644
--- a/core/src/fdrm/crypto/fx_crypt.cpp
+++ b/core/src/fdrm/crypto/fx_crypt.cpp
@@ -207,7 +207,7 @@
ctx->total[0] &= 0xFFFFFFFF;
ctx->total[1] += ctx->total[0] < length << 3;
if( left && length >= fill ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left), (void *) input, fill );
+ FXSYS_memcpy( (void *) (ctx->buffer + left), (void *) input, fill );
md5_process( ctx, ctx->buffer );
length -= fill;
input += fill;
@@ -219,7 +219,7 @@
input += 64;
}
if( length ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left), (void *) input, length );
+ FXSYS_memcpy( (void *) (ctx->buffer + left), (void *) input, length );
}
}
const uint8_t md5_padding[64] = {
diff --git a/core/src/fdrm/crypto/fx_crypt_aes.cpp b/core/src/fdrm/crypto/fx_crypt_aes.cpp
index 4de0f7e..107bfea 100644
--- a/core/src/fdrm/crypto/fx_crypt_aes.cpp
+++ b/core/src/fdrm/crypto/fx_crypt_aes.cpp
@@ -949,7 +949,7 @@
unsigned int iv[4], x[4], ct[4];
int i;
ASSERT((len & 15) == 0);
- FXSYS_memcpy32(iv, ctx->iv, sizeof(iv));
+ FXSYS_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);
@@ -963,7 +963,7 @@
src += 16;
len -= 16;
}
- FXSYS_memcpy32(ctx->iv, iv, sizeof(iv));
+ FXSYS_memcpy(ctx->iv, iv, sizeof(iv));
}
static void aes_encrypt(AESContext * ctx, unsigned int * block)
{
@@ -974,7 +974,7 @@
unsigned int iv[4];
int i;
ASSERT((len & 15) == 0);
- FXSYS_memcpy32(iv, ctx->iv, sizeof(iv));
+ FXSYS_memcpy(iv, ctx->iv, sizeof(iv));
while (len > 0) {
for (i = 0; i < 4; i++) {
iv[i] ^= GET_32BIT_MSB_FIRST(src + 4 * i);
@@ -987,7 +987,7 @@
src += 16;
len -= 16;
}
- FXSYS_memcpy32(ctx->iv, iv, sizeof(iv));
+ FXSYS_memcpy(ctx->iv, iv, sizeof(iv));
}
void CRYPT_AESSetKey(void* context, FX_DWORD blocklen, const uint8_t* key, FX_DWORD keylen, FX_BOOL bEncrypt)
{
diff --git a/core/src/fdrm/crypto/fx_crypt_sha.cpp b/core/src/fdrm/crypto/fx_crypt_sha.cpp
index 55a3f0e..ac77873 100644
--- a/core/src/fdrm/crypto/fx_crypt_sha.cpp
+++ b/core/src/fdrm/crypto/fx_crypt_sha.cpp
@@ -100,11 +100,11 @@
s->lenlo += lenw;
s->lenhi += (s->lenlo < lenw);
if (s->blkused && s->blkused + len < 64) {
- FXSYS_memcpy32(s->block + s->blkused, q, len);
+ FXSYS_memcpy(s->block + s->blkused, q, len);
s->blkused += len;
} else {
while (s->blkused + len >= 64) {
- FXSYS_memcpy32(s->block + s->blkused, q, 64 - s->blkused);
+ FXSYS_memcpy(s->block + s->blkused, q, 64 - s->blkused);
q += 64 - s->blkused;
len -= 64 - s->blkused;
for (i = 0; i < 16; i++) {
@@ -117,7 +117,7 @@
SHATransform(s->h, wordblock);
s->blkused = 0;
}
- FXSYS_memcpy32(s->block, q, len);
+ FXSYS_memcpy(s->block, q, len);
s->blkused = len;
}
}
@@ -135,7 +135,7 @@
}
lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
lenlo = (s->lenlo << 3);
- FXSYS_memset32(c, 0, pad);
+ FXSYS_memset(c, 0, pad);
c[0] = 0x80;
CRYPT_SHA1Update(s, c, pad);
c[0] = (lenhi >> 24) & 0xFF;
@@ -330,7 +330,7 @@
ctx->total[1]++;
}
if( left && length >= fill ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left),
+ FXSYS_memcpy( (void *) (ctx->buffer + left),
(void *) input, fill );
sha256_process( ctx, ctx->buffer );
length -= fill;
@@ -343,7 +343,7 @@
input += 64;
}
if( length ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left),
+ FXSYS_memcpy( (void *) (ctx->buffer + left),
(void *) input, length );
}
}
@@ -417,7 +417,7 @@
return;
}
sha384_context *ctx = (sha384_context *)context;
- FXSYS_memset32(ctx, 0, sizeof(sha384_context));
+ FXSYS_memset(ctx, 0, sizeof(sha384_context));
ctx->state[0] = FX_ato64i("cbbb9d5dc1059ed8");
ctx->state[1] = FX_ato64i("629a292a367cd507");
ctx->state[2] = FX_ato64i("9159015a3070dd17");
@@ -638,7 +638,7 @@
ctx->total[1]++;
}
if( left && length >= fill ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left),
+ FXSYS_memcpy( (void *) (ctx->buffer + left),
(void *) input, fill );
sha384_process( ctx, ctx->buffer );
length -= fill;
@@ -651,7 +651,7 @@
input += 128;
}
if( length ) {
- FXSYS_memcpy32( (void *) (ctx->buffer + left),
+ FXSYS_memcpy( (void *) (ctx->buffer + left),
(void *) input, length );
}
}
@@ -660,7 +660,7 @@
sha384_context *ctx = (sha384_context *)context;
FX_DWORD last, padn;
uint8_t msglen[16];
- FXSYS_memset32(msglen, 0, 16);
+ FXSYS_memset(msglen, 0, 16);
uint64_t high, low;
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
@@ -691,7 +691,7 @@
return;
}
sha384_context *ctx = (sha384_context *)context;
- FXSYS_memset32(ctx, 0, sizeof(sha384_context));
+ FXSYS_memset(ctx, 0, sizeof(sha384_context));
ctx->state[0] = FX_ato64i("6a09e667f3bcc908");
ctx->state[1] = FX_ato64i("bb67ae8584caa73b");
ctx->state[2] = FX_ato64i("3c6ef372fe94f82b");
@@ -710,7 +710,7 @@
sha384_context *ctx = (sha384_context *)context;
FX_DWORD last, padn;
uint8_t msglen[16];
- FXSYS_memset32(msglen, 0, 16);
+ FXSYS_memset(msglen, 0, 16);
uint64_t high, low;
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
index 8cfbd1b..948908e 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
@@ -144,7 +144,7 @@
int pos = 0;
uint8_t* pBuf = FX_Alloc(uint8_t, size);
for (i = 0; i < iCount; ++i) {
- FXSYS_memcpy32(pBuf + pos, pContentArray[i]->GetData(), pContentArray[i]->GetSize());
+ FXSYS_memcpy(pBuf + pos, pContentArray[i]->GetData(), pContentArray[i]->GetSize());
pos += pContentArray[i]->GetSize() + 1;
pBuf[pos - 1] = ' ';
delete pContentArray[i];
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
index 0091613..93531de 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
@@ -752,7 +752,7 @@
return -1;
}
FX_CHAR offset_buf[20];
- FXSYS_memset32(offset_buf, 0, sizeof(offset_buf));
+ FXSYS_memset(offset_buf, 0, sizeof(offset_buf));
FXSYS_i64toa(m_PrevOffset, offset_buf, 10);
int32_t len = (int32_t)FXSYS_strlen(offset_buf);
if (pFile->AppendBlock(offset_buf, len) < 0) {
@@ -1863,7 +1863,7 @@
return -1;
}
FX_CHAR offset_buf[20];
- FXSYS_memset32(offset_buf, 0, sizeof(offset_buf));
+ FXSYS_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;
@@ -1952,7 +1952,7 @@
return -1;
}
FX_CHAR offset_buf[20];
- FXSYS_memset32(offset_buf, 0, sizeof(offset_buf));
+ FXSYS_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/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
index 18913a0..e6e688f 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
@@ -218,7 +218,7 @@
CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont, FX_BOOL bVert, FX_BOOL bTranslateName)
{
LOGFONTA lfa;
- FXSYS_memcpy32(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa);
+ FXSYS_memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa);
CFX_ByteString face = CFX_ByteString::FromUnicode(pLogFont->lfFaceName);
if (face.GetLength() >= LF_FACESIZE) {
return NULL;
@@ -608,7 +608,7 @@
CFX_ByteString basefont;
FX_BOOL bCJK = FALSE;
int flags = 0, italicangle = 0, ascend = 0, descend = 0, capheight = 0, bbox[4];
- FXSYS_memset32(bbox, 0, sizeof(int) * 4);
+ FXSYS_memset(bbox, 0, sizeof(int) * 4);
CFArrayRef languages = (CFArrayRef)CTFontDescriptorCopyAttribute(descriptor, kCTFontLanguagesAttribute);
if (languages == NULL) {
CFRelease(descriptor);
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
index fd71524..ba0358f 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
@@ -221,7 +221,7 @@
mask_buf = FX_Alloc2D(uint8_t, maskHeight, maskWidth);
mask_size = maskHeight * maskWidth; // Safe since checked alloc returned.
for (int32_t a = 0; a < maskHeight; a ++) {
- FXSYS_memcpy32(mask_buf + a * maskWidth, pMaskBitmap->GetScanline(a), maskWidth);
+ FXSYS_memcpy(mask_buf + a * maskWidth, pMaskBitmap->GetScanline(a), maskWidth);
}
}
pMaskDict->SetAtInteger(FX_BSTRC("Length"), mask_size);
@@ -303,7 +303,7 @@
uint8_t* pDest = dest_buf;
for (int32_t i = 0; i < BitmapHeight; i ++) {
if (!bStream) {
- FXSYS_memcpy32(pDest, src_buf, dest_pitch);
+ FXSYS_memcpy(pDest, src_buf, dest_pitch);
pDest += dest_pitch;
} else {
pFileWrite->WriteBlock(src_buf, dest_pitch);
diff --git a/core/src/fpdfapi/fpdf_font/fpdf_font.cpp b/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
index 48a96dc..345e291 100644
--- a/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
+++ b/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
@@ -26,8 +26,8 @@
CPDF_FontGlobals::CPDF_FontGlobals()
: m_pContrastRamps(NULL)
{
- FXSYS_memset32(m_EmbeddedCharsets, 0, sizeof(m_EmbeddedCharsets));
- FXSYS_memset32(m_EmbeddedToUnicodes, 0, sizeof(m_EmbeddedToUnicodes));
+ FXSYS_memset(m_EmbeddedCharsets, 0, sizeof(m_EmbeddedCharsets));
+ FXSYS_memset(m_EmbeddedToUnicodes, 0, sizeof(m_EmbeddedToUnicodes));
}
CPDF_FontGlobals::~CPDF_FontGlobals()
{
@@ -41,7 +41,7 @@
public:
CFX_StockFontArray()
{
- FXSYS_memset32(m_pStockFonts, 0, sizeof(m_pStockFonts));
+ FXSYS_memset(m_pStockFonts, 0, sizeof(m_pStockFonts));
}
~CFX_StockFontArray()
{
@@ -819,10 +819,10 @@
extern const FX_CHAR* PDF_CharNameFromPredefinedCharSet(int encoding, uint8_t charcode);
CPDF_SimpleFont::CPDF_SimpleFont(int fonttype) : CPDF_Font(fonttype)
{
- FXSYS_memset8(m_CharBBox, 0xff, sizeof m_CharBBox);
- FXSYS_memset8(m_CharWidth, 0xff, sizeof m_CharWidth);
- FXSYS_memset8(m_GlyphIndex, 0xff, sizeof m_GlyphIndex);
- FXSYS_memset8(m_ExtGID, 0xff, sizeof m_ExtGID);
+ FXSYS_memset(m_CharBBox, 0xff, sizeof m_CharBBox);
+ FXSYS_memset(m_CharWidth, 0xff, sizeof m_CharWidth);
+ FXSYS_memset(m_GlyphIndex, 0xff, sizeof m_GlyphIndex);
+ FXSYS_memset(m_ExtGID, 0xff, sizeof m_ExtGID);
m_pCharNames = NULL;
m_BaseEncoding = PDFFONT_ENCODING_BUILTIN;
}
@@ -1153,7 +1153,7 @@
if (bGotOne) {
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (!bCoreText) {
- FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
+ FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
}
#endif
return;
@@ -1197,7 +1197,7 @@
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (!bCoreText) {
- FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
+ FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
}
#endif
return;
@@ -1223,7 +1223,7 @@
unicode = FT_UnicodeFromCharCode(PDFFONT_ENCODING_STANDARD, charcode);
}
FX_CHAR name_glyph[256];
- FXSYS_memset32(name_glyph, 0, sizeof(name_glyph));
+ FXSYS_memset(name_glyph, 0, sizeof(name_glyph));
FXFT_Get_Glyph_Name(m_Font.m_Face, m_GlyphIndex[charcode], name_glyph, 256);
name_glyph[255] = 0;
if (unicode == 0 && name_glyph[0] != 0) {
@@ -1299,7 +1299,7 @@
FX_WCHAR unicode = FT_UnicodeFromCharCode(PDFFONT_ENCODING_STANDARD, charcode);
if (unicode == 0) {
FX_CHAR name_glyph[256];
- FXSYS_memset32(name_glyph, 0, sizeof(name_glyph));
+ FXSYS_memset(name_glyph, 0, sizeof(name_glyph));
FXFT_Get_Glyph_Name(m_Font.m_Face, m_GlyphIndex[charcode], name_glyph, 256);
name_glyph[255] = 0;
if (name_glyph[0] != 0) {
@@ -1312,7 +1312,7 @@
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (!bCoreText) {
- FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
+ FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
}
#endif
return;
@@ -1339,13 +1339,13 @@
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (!bCoreText) {
- FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
+ FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
}
#endif
}
CPDF_FontEncoding::CPDF_FontEncoding()
{
- FXSYS_memset32(m_Unicodes, 0, sizeof(m_Unicodes));
+ FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
}
int CPDF_FontEncoding::CharCodeFromUnicode(FX_WCHAR unicode) const
{
@@ -1359,7 +1359,7 @@
{
const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding);
if (!pSrc) {
- FXSYS_memset32(m_Unicodes, 0, sizeof(m_Unicodes));
+ FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
} else
for (int i = 0; i < 256; i++) {
m_Unicodes[i] = pSrc[i];
@@ -1367,7 +1367,7 @@
}
FX_BOOL CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const
{
- return FXSYS_memcmp32(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) == 0;
+ return FXSYS_memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) == 0;
}
CPDF_Object* CPDF_FontEncoding::Realize()
{
@@ -1597,7 +1597,7 @@
CPDF_Type3Font::CPDF_Type3Font() : CPDF_SimpleFont(PDFFONT_TYPE3)
{
m_pPageResources = NULL;
- FXSYS_memset32(m_CharWidthL, 0, sizeof m_CharWidthL);
+ FXSYS_memset(m_CharWidthL, 0, sizeof m_CharWidthL);
}
CPDF_Type3Font::~CPDF_Type3Font()
{
diff --git a/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp b/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
index ed5ef5c..7726981 100644
--- a/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
+++ b/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
@@ -17,7 +17,7 @@
CPDF_CMapManager::CPDF_CMapManager()
{
m_bPrompted = FALSE;
- FXSYS_memset32(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
+ FXSYS_memset(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
}
CPDF_CMapManager::~CPDF_CMapManager()
{
@@ -255,7 +255,7 @@
m_pCMap->m_CodingScheme = CPDF_CMap::MixedFourBytes;
m_pCMap->m_nCodeRanges = nSegs;
m_pCMap->m_pLeadingBytes = FX_Alloc2D(uint8_t, nSegs, sizeof(_CMap_CodeRange));
- FXSYS_memcpy32(m_pCMap->m_pLeadingBytes, m_CodeRanges.GetData(), nSegs * sizeof(_CMap_CodeRange));
+ FXSYS_memcpy(m_pCMap->m_pLeadingBytes, m_CodeRanges.GetData(), nSegs * sizeof(_CMap_CodeRange));
} else if (nSegs == 1) {
m_pCMap->m_CodingScheme = (m_CodeRanges[0].m_CharSize == 2) ? CPDF_CMap::TwoBytes : CPDF_CMap::OneByte;
}
@@ -412,7 +412,7 @@
if (m_CodingScheme == MixedFourBytes && parser.m_AddMaps.GetSize()) {
m_pAddMapping = FX_Alloc(uint8_t, parser.m_AddMaps.GetSize() + 4);
*(FX_DWORD*)m_pAddMapping = parser.m_AddMaps.GetSize() / 8;
- FXSYS_memcpy32(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), parser.m_AddMaps.GetSize());
+ FXSYS_memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), parser.m_AddMaps.GetSize());
FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8, compare_dword);
}
return TRUE;
@@ -638,7 +638,7 @@
iSize = 1;
}
if (iSize > 1) {
- FXSYS_memset32(str, 0, sizeof(uint8_t) * iSize);
+ FXSYS_memset(str, 0, sizeof(uint8_t) * iSize);
}
str[iSize - 1] = (uint8_t)charcode;
return iSize;
@@ -703,7 +703,7 @@
m_bCIDIsGID = FALSE;
m_bAdobeCourierStd = FALSE;
m_pTTGSUBTable = NULL;
- FXSYS_memset8(m_CharBBox, 0xff, 256 * sizeof(FX_SMALL_RECT));
+ FXSYS_memset(m_CharBBox, 0xff, 256 * sizeof(FX_SMALL_RECT));
}
CPDF_CIDFont::~CPDF_CIDFont()
{
diff --git a/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp b/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
index b6b2f57..62c9fe5 100644
--- a/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
+++ b/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
@@ -254,7 +254,7 @@
return;
}
rec->FeatureIndex = new TT_uint16_t[rec->FeatureCount];
- FXSYS_memset32(rec->FeatureIndex, 0, sizeof(TT_uint16_t) * rec->FeatureCount);
+ FXSYS_memset(rec->FeatureIndex, 0, sizeof(TT_uint16_t) * rec->FeatureCount);
for (int i = 0; i < rec->FeatureCount; ++i) {
rec->FeatureIndex[i] = GetUInt16(sp);
}
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
index 688066e..8c6de8e 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
@@ -586,9 +586,9 @@
m_pCharCodes = (FX_DWORD*)(uintptr_t) * pCharCodes;
} else {
m_pCharCodes = FX_Alloc(FX_DWORD, nChars);
- FXSYS_memcpy32(m_pCharCodes, pCharCodes, sizeof(FX_DWORD)*nChars);
+ FXSYS_memcpy(m_pCharCodes, pCharCodes, sizeof(FX_DWORD)*nChars);
m_pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
- FXSYS_memcpy32(m_pCharPos, pCharPos, sizeof(FX_FLOAT) * (nChars - 1));
+ FXSYS_memcpy(m_pCharPos, pCharPos, sizeof(FX_FLOAT) * (nChars - 1));
}
RecalcPositionData();
}
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
index dc3d454..8dd1359 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
@@ -526,7 +526,7 @@
m_pTransform(NULL),
m_nSrcComponents(0)
{
- if (dwSize == 3144 && FXSYS_memcmp32(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0) {
+ if (dwSize == 3144 && FXSYS_memcmp(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0) {
m_bsRGB = TRUE;
m_nSrcComponents = 3;
}
@@ -1351,7 +1351,7 @@
return;
}
if (m_pCS->GetFamily() != PDFCS_PATTERN) {
- FXSYS_memcpy32(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(FX_FLOAT));
+ FXSYS_memcpy(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(FX_FLOAT));
}
}
void CPDF_Color::SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comps, int ncomps)
@@ -1377,7 +1377,7 @@
pvalue->m_nComps = ncomps;
pvalue->m_pPattern = pPattern;
if (ncomps) {
- FXSYS_memcpy32(pvalue->m_Comps, comps, ncomps * sizeof(FX_FLOAT));
+ FXSYS_memcpy(pvalue->m_Comps, comps, ncomps * sizeof(FX_FLOAT));
}
pvalue->m_pCountedPattern = NULL;
if (pPattern && pPattern->m_pDocument)
@@ -1403,7 +1403,7 @@
return;
}
m_pBuffer = m_pCS->CreateBuf();
- FXSYS_memcpy32(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());
+ FXSYS_memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());
if (m_pCS->GetFamily() == PDFCS_PATTERN) {
PatternValue* pvalue = (PatternValue*)m_pBuffer;
if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
@@ -1453,5 +1453,5 @@
if (m_pCS != other.m_pCS || m_pCS == NULL) {
return FALSE;
}
- return FXSYS_memcmp32(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
+ return FXSYS_memcmp(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
}
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
index 2cfb028..f1a8433 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
@@ -873,7 +873,7 @@
if (m_pRanges && m_nOutputs > (int)old_outputs) {
m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
if (m_pRanges) {
- FXSYS_memset32(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
+ FXSYS_memset(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
}
}
return ret;
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
index 8752acf..178db75 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
@@ -61,7 +61,7 @@
m_pPathList[i] = src.m_pPathList[i];
}
m_pTypeList = FX_Alloc(uint8_t, alloc_size);
- FXSYS_memcpy32(m_pTypeList, src.m_pTypeList, m_PathCount);
+ FXSYS_memcpy(m_pTypeList, src.m_pTypeList, m_PathCount);
} else {
m_pPathList = NULL;
m_pTypeList = NULL;
@@ -156,7 +156,7 @@
}
delete[] pData->m_pPathList;
uint8_t* pNewType = FX_Alloc(uint8_t, pData->m_PathCount + 8);
- FXSYS_memcpy32(pNewType, pData->m_pTypeList, pData->m_PathCount);
+ FXSYS_memcpy(pNewType, pData->m_pTypeList, pData->m_PathCount);
if (pData->m_pTypeList) {
FX_Free(pData->m_pTypeList);
}
@@ -178,7 +178,7 @@
pData->m_pPathList[i] = pData->m_pPathList[i + 1];
}
pData->m_pPathList[pData->m_PathCount - 1].SetNull();
- FXSYS_memmove32(pData->m_pTypeList + index, pData->m_pTypeList + index + 1, pData->m_PathCount - index - 1);
+ FXSYS_memmove(pData->m_pTypeList + index, pData->m_pTypeList + index + 1, pData->m_PathCount - index - 1);
pData->m_PathCount --;
}
#define FPDF_CLIPPATH_MAX_TEXTS 1024
@@ -193,7 +193,7 @@
}
CPDF_TextObject** pNewList = FX_Alloc(CPDF_TextObject*, pData->m_TextCount + count + 1);
if (pData->m_pTextList) {
- FXSYS_memcpy32(pNewList, pData->m_pTextList, pData->m_TextCount * sizeof(CPDF_TextObject*));
+ FXSYS_memcpy(pNewList, pData->m_pTextList, pData->m_TextCount * sizeof(CPDF_TextObject*));
FX_Free(pData->m_pTextList);
}
pData->m_pTextList = pNewList;
@@ -294,7 +294,7 @@
if (this == &src) {
return;
}
- FXSYS_memcpy32(this, &src, sizeof(CPDF_TextStateData));
+ FXSYS_memcpy(this, &src, sizeof(CPDF_TextStateData));
if (m_pDocument && m_pFont) {
m_pFont = m_pDocument->GetPageData()->GetFont(m_pFont->GetFontDict(), FALSE);
}
@@ -348,7 +348,7 @@
}
CPDF_GeneralStateData::CPDF_GeneralStateData()
{
- FXSYS_memset32(this, 0, sizeof(CPDF_GeneralStateData));
+ FXSYS_memset(this, 0, sizeof(CPDF_GeneralStateData));
FXSYS_strcpy((FX_CHAR*)m_BlendMode, "Normal");
m_StrokeAlpha = 1.0f;
m_FillAlpha = 1.0f;
@@ -357,7 +357,7 @@
}
CPDF_GeneralStateData::CPDF_GeneralStateData(const CPDF_GeneralStateData& src)
{
- FXSYS_memcpy32(this, &src, sizeof(CPDF_GeneralStateData));
+ FXSYS_memcpy(this, &src, sizeof(CPDF_GeneralStateData));
if (src.m_pTransferFunc && src.m_pTransferFunc->m_pPDFDoc) {
CPDF_DocRenderData* pDocCache = src.m_pTransferFunc->m_pPDFDoc->GetRenderData();
if (!pDocCache) {
@@ -422,7 +422,7 @@
if (blend_mode.GetLength() > 15) {
return;
}
- FXSYS_memcpy32(m_BlendMode, blend_mode.GetPtr(), blend_mode.GetLength());
+ FXSYS_memcpy(m_BlendMode, blend_mode.GetPtr(), blend_mode.GetLength());
m_BlendMode[blend_mode.GetLength()] = 0;
m_BlendType = ::GetBlendType(blend_mode);
}
@@ -553,7 +553,7 @@
case FXBSTR_ID('S', 'M', 'a', 's'):
if (pObject && pObject->GetType() == PDFOBJ_DICTIONARY) {
pGeneralState->m_pSoftMask = pObject;
- FXSYS_memcpy32(pGeneralState->m_SMaskMatrix, &pParser->m_pCurStates->m_CTM, sizeof(CPDF_Matrix));
+ FXSYS_memcpy(pGeneralState->m_SMaskMatrix, &pParser->m_pCurStates->m_CTM, sizeof(CPDF_Matrix));
} else {
pGeneralState->m_pSoftMask = NULL;
}
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
index ebe7548..8760547 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
@@ -20,7 +20,7 @@
m_PathCurrentX = m_PathCurrentY = 0.0f;
m_bResourceMissing = FALSE;
m_bColored = FALSE;
- FXSYS_memset32(m_Type3Data, 0, sizeof(FX_FLOAT) * 6);
+ FXSYS_memset(m_Type3Data, 0, sizeof(FX_FLOAT) * 6);
m_ParamCount = 0;
m_ParamStartPos = 0;
m_bAbort = FALSE;
@@ -122,11 +122,11 @@
} else {
m_ParamBuf1[index].m_Type = PDFOBJ_NAME;
if (FXSYS_memchr(name, '#', len) == NULL) {
- FXSYS_memcpy32(m_ParamBuf1[index].m_Name.m_Buffer, name, len);
+ FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, name, len);
m_ParamBuf1[index].m_Name.m_Len = len;
} else {
CFX_ByteString str = PDF_NameDecode(CFX_ByteStringC(name, len));
- FXSYS_memcpy32(m_ParamBuf1[index].m_Name.m_Buffer, str.c_str(), str.GetLength());
+ FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, str.c_str(), str.GetLength());
m_ParamBuf1[index].m_Name.m_Len = str.GetLength();
}
}
@@ -442,7 +442,7 @@
{
int i = 0;
while (i < count) {
- if (abbr.GetLength() == table[i + 1].m_Size && FXSYS_memcmp32(abbr.GetPtr(), table[i + 1].m_Ptr, abbr.GetLength()) == 0) {
+ if (abbr.GetLength() == table[i + 1].m_Size && FXSYS_memcmp(abbr.GetPtr(), table[i + 1].m_Ptr, abbr.GetLength()) == 0) {
return CFX_ByteStringC(table[i].m_Ptr, table[i].m_Size);
}
i += 2;
@@ -500,7 +500,7 @@
{
int i = 0;
while (i < count) {
- if (fullName.GetLength() == table[i].m_Size && FXSYS_memcmp32(fullName.GetPtr(), table[i].m_Ptr, fullName.GetLength()) == 0) {
+ if (fullName.GetLength() == table[i].m_Size && FXSYS_memcmp(fullName.GetPtr(), table[i].m_Ptr, fullName.GetLength()) == 0) {
return CFX_ByteStringC(table[i + 1].m_Ptr, table[i + 1].m_Size);
}
i += 2;
@@ -1495,7 +1495,7 @@
int newsize = m_PathPointCount + 256;
FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
if (m_PathAllocSize) {
- FXSYS_memcpy32(pNewPoints, m_pPathPoints, m_PathAllocSize * sizeof(FX_PATHPOINT));
+ FXSYS_memcpy(pNewPoints, m_pPathPoints, m_PathAllocSize * sizeof(FX_PATHPOINT));
FX_Free(m_pPathPoints);
}
m_pPathPoints = pNewPoints;
@@ -1524,7 +1524,7 @@
CPDF_Path Path;
CFX_PathData* pPathData = Path.New();
pPathData->SetPointCount(PathPointCount);
- FXSYS_memcpy32(pPathData->GetPoints(), m_pPathPoints, sizeof(FX_PATHPOINT) * PathPointCount);
+ FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints, sizeof(FX_PATHPOINT) * PathPointCount);
CFX_AffineMatrix matrix = m_pCurStates->m_CTM;
matrix.Concat(m_mtContentToUser);
if (bStroke || FillType) {
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
index ec2b69f..d829acb 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
@@ -269,7 +269,7 @@
if (pLine == NULL) {
break;
}
- FXSYS_memcpy32(dest_buf + row * pitch, pLine, pitch);
+ FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);
}
FX_DWORD srcoff = pDecoder->GetSrcOffset();
delete pDecoder;
@@ -374,7 +374,7 @@
OrigSize = m_Size - m_Pos;
}
pData = FX_Alloc(uint8_t, OrigSize);
- FXSYS_memcpy32(pData, m_pBuf + m_Pos, OrigSize);
+ FXSYS_memcpy(pData, m_pBuf + m_Pos, OrigSize);
dwStreamSize = OrigSize;
m_Pos += OrigSize;
} else {
@@ -422,7 +422,7 @@
}
m_Pos = dwSavePos;
pData = FX_Alloc(uint8_t, dwStreamSize);
- FXSYS_memcpy32(pData, m_pBuf + m_Pos, dwStreamSize);
+ FXSYS_memcpy(pData, m_pBuf + m_Pos, dwStreamSize);
m_Pos += dwStreamSize;
}
}
@@ -1052,7 +1052,7 @@
m_pData = FX_Alloc(uint8_t, m_Size);
FX_DWORD pos = 0;
for (i = 0; i < m_nStreams; i ++) {
- FXSYS_memcpy32(m_pData + pos, m_pStreamArray[i]->GetData(), m_pStreamArray[i]->GetSize());
+ FXSYS_memcpy(m_pData + pos, m_pStreamArray[i]->GetData(), m_pStreamArray[i]->GetSize());
pos += m_pStreamArray[i]->GetSize() + 1;
m_pData[pos - 1] = ' ';
delete m_pStreamArray[i];
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
index d23d75a..2aa66d7 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
@@ -217,7 +217,7 @@
static const int kMaxResults = 8;
FX_FLOAT result[kMaxResults];
int nResults;
- FXSYS_memset32(result, 0, sizeof(result));
+ FXSYS_memset(result, 0, sizeof(result));
for (FX_DWORD i = 0; i < m_nFuncs; i ++) {
if (m_pFuncs[i] && m_pFuncs[i]->CountOutputs() <= kMaxResults) {
m_pFuncs[i]->Call(color_value, 1, result, nResults);
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
index bb49063..9736c3d 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
@@ -49,7 +49,7 @@
continue;
}
if (ch == 'z') {
- FXSYS_memset32(dest_buf + dest_size, 0, 4);
+ FXSYS_memset(dest_buf + dest_size, 0, 4);
state = 0;
res = 0;
dest_size += 4;
@@ -159,9 +159,9 @@
if (buf_left < copy_len) {
FX_DWORD delta = copy_len - buf_left;
copy_len = buf_left;
- FXSYS_memset8(dest_buf + dest_count + copy_len, '\0', delta);
+ FXSYS_memset(dest_buf + dest_count + copy_len, '\0', delta);
}
- FXSYS_memcpy32(dest_buf + dest_count, src_buf + i + 1, copy_len);
+ FXSYS_memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len);
dest_count += src_buf[i] + 1;
i += src_buf[i] + 2;
} else if (src_buf[i] > 128) {
@@ -169,7 +169,7 @@
if (i < src_size - 1) {
fill = src_buf[i + 1];
}
- FXSYS_memset8(dest_buf + dest_count, fill, 257 - src_buf[i]);
+ FXSYS_memset(dest_buf + dest_count, fill, 257 - src_buf[i]);
dest_count += 257 - src_buf[i];
i += 2;
} else {
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
index b4366ba..43a5c5f 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
@@ -47,8 +47,8 @@
CRYPT_MD5Generate(digest, copy_len, digest);
}
}
- FXSYS_memset32(key, 0, keylen);
- FXSYS_memcpy32(key, digest, copy_len);
+ FXSYS_memset(key, 0, keylen);
+ FXSYS_memcpy(key, digest, copy_len);
}
CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler()
{
@@ -285,7 +285,7 @@
}
FX_Free(aes);
if (hash) {
- FXSYS_memcpy32(hash, input, 32);
+ FXSYS_memcpy(hash, input, 32);
}
}
FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* password, FX_DWORD size,
@@ -313,7 +313,7 @@
}
CRYPT_SHA256Finish(sha, digest);
}
- if (FXSYS_memcmp32(digest, pkey, 32) != 0) {
+ if (FXSYS_memcmp(digest, pkey, 32) != 0) {
return FALSE;
}
if (key == NULL) {
@@ -337,7 +337,7 @@
uint8_t* aes = FX_Alloc(uint8_t, 2048);
CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
uint8_t iv[16];
- FXSYS_memset32(iv, 0, 16);
+ FXSYS_memset(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESDecrypt(aes, key, ekey, 32);
CRYPT_AESSetKey(aes, 16, key, 32, FALSE);
@@ -347,12 +347,12 @@
return FALSE;
}
uint8_t perms_buf[16];
- FXSYS_memset32(perms_buf, 0, sizeof(perms_buf));
+ FXSYS_memset(perms_buf, 0, sizeof(perms_buf));
FX_DWORD copy_len = sizeof(perms_buf);
if (copy_len > (FX_DWORD)perms.GetLength()) {
copy_len = perms.GetLength();
}
- FXSYS_memcpy32(perms_buf, (const uint8_t*)perms, copy_len);
+ FXSYS_memcpy(perms_buf, (const uint8_t*)perms, copy_len);
uint8_t buf[16];
CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
FX_Free(aes);
@@ -396,7 +396,7 @@
}
uint8_t ukeybuf[32];
if (m_Revision == 2) {
- FXSYS_memcpy32(ukeybuf, defpasscode, 32);
+ FXSYS_memcpy(ukeybuf, defpasscode, 32);
CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
} else {
uint8_t test[32], tmpkey[32];
@@ -404,9 +404,9 @@
if (copy_len > (FX_DWORD)ukey.GetLength()) {
copy_len = ukey.GetLength();
}
- FXSYS_memset32(test, 0, sizeof(test));
- FXSYS_memset32(tmpkey, 0, sizeof(tmpkey));
- FXSYS_memcpy32(test, ukey.c_str(), copy_len);
+ FXSYS_memset(test, 0, sizeof(test));
+ FXSYS_memset(tmpkey, 0, sizeof(tmpkey));
+ FXSYS_memcpy(test, ukey.c_str(), copy_len);
for (int i = 19; i >= 0; i --) {
for (int j = 0; j < key_len; j ++) {
tmpkey[j] = key[j] ^ i;
@@ -422,9 +422,9 @@
CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
}
CRYPT_MD5Finish(md5, ukeybuf);
- return FXSYS_memcmp32(test, ukeybuf, 16) == 0;
+ return FXSYS_memcmp(test, ukeybuf, 16) == 0;
}
- if (FXSYS_memcmp32((void*)ukey.c_str(), ukeybuf, 16) == 0) {
+ if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {
return TRUE;
}
return FALSE;
@@ -449,25 +449,25 @@
}
}
uint8_t enckey[32];
- FXSYS_memset32(enckey, 0, sizeof(enckey));
+ FXSYS_memset(enckey, 0, sizeof(enckey));
FX_DWORD copy_len = key_len;
if (copy_len > sizeof(digest)) {
copy_len = sizeof(digest);
}
- FXSYS_memcpy32(enckey, digest, copy_len);
+ FXSYS_memcpy(enckey, digest, copy_len);
int okeylen = okey.GetLength();
if (okeylen > 32) {
okeylen = 32;
}
uint8_t okeybuf[64];
- FXSYS_memset32(okeybuf, 0, sizeof(okeybuf));
- FXSYS_memcpy32(okeybuf, okey.c_str(), okeylen);
+ FXSYS_memset(okeybuf, 0, sizeof(okeybuf));
+ FXSYS_memcpy(okeybuf, okey.c_str(), okeylen);
if (m_Revision == 2) {
CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);
} else {
for (int i = 19; i >= 0; i --) {
uint8_t tempkey[32];
- FXSYS_memset32(tempkey, 0, sizeof(tempkey));
+ FXSYS_memset(tempkey, 0, sizeof(tempkey));
for (int j = 0; j < m_KeyLen; j ++) {
tempkey[j] = enckey[j] ^ i;
}
@@ -538,7 +538,7 @@
}
}
uint8_t enckey[32];
- FXSYS_memcpy32(enckey, digest, key_len);
+ FXSYS_memcpy(enckey, digest, key_len);
for (i = 0; i < 32; i ++) {
passcode[i] = i < user_size ? user_pass[i] : defpasscode[i - user_size];
}
@@ -557,7 +557,7 @@
CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey, key_len, FALSE, pIdArray);
if (m_Revision < 3) {
uint8_t tempbuf[32];
- FXSYS_memcpy32(tempbuf, defpasscode, 32);
+ FXSYS_memcpy(tempbuf, defpasscode, 32);
CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len);
pEncryptDict->SetAtString(FX_BSTRC("U"), CFX_ByteString(tempbuf, 32));
} else {
@@ -613,7 +613,7 @@
}
CRYPT_SHA256Finish(sha, digest1);
}
- FXSYS_memcpy32(digest1 + 32, digest, 16);
+ FXSYS_memcpy(digest1 + 32, digest, 16);
pEncryptDict->SetAtString(bOwner ? FX_BSTRC("O") : FX_BSTRC("U"), CFX_ByteString(digest1, 48));
if (m_Revision >= 6) {
Revision6_Hash(password, size, digest + 8, (bOwner ? (const uint8_t*)ukey : NULL), digest1);
@@ -629,7 +629,7 @@
uint8_t* aes = FX_Alloc(uint8_t, 2048);
CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);
uint8_t iv[16];
- FXSYS_memset32(iv, 0, 16);
+ FXSYS_memset(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, digest1, key, 32);
FX_Free(aes);
@@ -654,7 +654,7 @@
uint8_t* aes = FX_Alloc(uint8_t, 2048);
CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
uint8_t iv[16], buf1[16];
- FXSYS_memset32(iv, 0, 16);
+ FXSYS_memset(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, buf1, buf, 16);
FX_Free(aes);
@@ -664,23 +664,23 @@
uint8_t* dest_buf, FX_DWORD& dest_size)
{
if (m_Cipher == FXCIPHER_NONE) {
- FXSYS_memcpy32(dest_buf, src_buf, src_size);
+ FXSYS_memcpy(dest_buf, src_buf, src_size);
return;
}
uint8_t realkey[16];
int realkeylen = 16;
if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {
uint8_t key1[32];
- FXSYS_memcpy32(key1, m_EncryptKey, m_KeyLen);
+ FXSYS_memcpy(key1, m_EncryptKey, m_KeyLen);
key1[m_KeyLen + 0] = (uint8_t)objnum;
key1[m_KeyLen + 1] = (uint8_t)(objnum >> 8);
key1[m_KeyLen + 2] = (uint8_t)(objnum >> 16);
key1[m_KeyLen + 3] = (uint8_t)gennum;
key1[m_KeyLen + 4] = (uint8_t)(gennum >> 8);
- FXSYS_memcpy32(key1 + m_KeyLen, &objnum, 3);
- FXSYS_memcpy32(key1 + m_KeyLen + 3, &gennum, 2);
+ FXSYS_memcpy(key1 + m_KeyLen, &objnum, 3);
+ FXSYS_memcpy(key1 + m_KeyLen + 3, &gennum, 2);
if (m_Cipher == FXCIPHER_AES) {
- FXSYS_memcpy32(key1 + m_KeyLen + 5, "sAlT", 4);
+ FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4);
}
CRYPT_MD5Generate(key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);
realkeylen = m_KeyLen + 5;
@@ -696,12 +696,12 @@
iv[i] = (uint8_t)rand();
}
CRYPT_AESSetIV(m_pAESContext, iv);
- FXSYS_memcpy32(dest_buf, iv, 16);
+ FXSYS_memcpy(dest_buf, iv, 16);
int nblocks = src_size / 16;
CRYPT_AESEncrypt(m_pAESContext, dest_buf + 16, src_buf, nblocks * 16);
uint8_t padding[16];
- FXSYS_memcpy32(padding, src_buf + nblocks * 16, src_size % 16);
- FXSYS_memset8(padding + src_size % 16, 16 - src_size % 16, 16 - src_size % 16);
+ FXSYS_memcpy(padding, src_buf + nblocks * 16, src_size % 16);
+ FXSYS_memset(padding + src_size % 16, 16 - src_size % 16, 16 - src_size % 16);
CRYPT_AESEncrypt(m_pAESContext, dest_buf + nblocks * 16 + 16, padding, 16);
dest_size = 32 + nblocks * 16;
} else {
@@ -713,7 +713,7 @@
} else {
ASSERT(dest_size == src_size);
if (dest_buf != src_buf) {
- FXSYS_memcpy32(dest_buf, src_buf, src_size);
+ FXSYS_memcpy(dest_buf, src_buf, src_size);
}
CRYPT_ArcFourCryptBlock(dest_buf, dest_size, realkey, realkeylen);
}
@@ -743,11 +743,11 @@
return pContext;
}
uint8_t key1[48];
- FXSYS_memcpy32(key1, m_EncryptKey, m_KeyLen);
- FXSYS_memcpy32(key1 + m_KeyLen, &objnum, 3);
- FXSYS_memcpy32(key1 + m_KeyLen + 3, &gennum, 2);
+ FXSYS_memcpy(key1, m_EncryptKey, m_KeyLen);
+ FXSYS_memcpy(key1 + m_KeyLen, &objnum, 3);
+ FXSYS_memcpy(key1 + m_KeyLen + 3, &gennum, 2);
if (m_Cipher == FXCIPHER_AES) {
- FXSYS_memcpy32(key1 + m_KeyLen + 5, "sAlT", 4);
+ FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4);
}
uint8_t realkey[16];
CRYPT_MD5Generate(key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);
@@ -799,7 +799,7 @@
if (copy_size > src_left) {
copy_size = src_left;
}
- FXSYS_memcpy32(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off, copy_size);
+ FXSYS_memcpy(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off, copy_size);
src_off += copy_size;
src_left -= copy_size;
pContext->m_BlockOffset += copy_size;
@@ -845,7 +845,7 @@
dest_buf.AppendBlock(block_buf, 16);
pContext->m_BlockOffset = 0;
}
- FXSYS_memset8(pContext->m_Block + pContext->m_BlockOffset, (uint8_t)(16 - pContext->m_BlockOffset), 16 - pContext->m_BlockOffset);
+ FXSYS_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) {
@@ -876,7 +876,7 @@
return FALSE;
}
if (m_Cipher != FXCIPHER_NONE) {
- FXSYS_memcpy32(m_EncryptKey, key, m_KeyLen);
+ FXSYS_memcpy(m_EncryptKey, key, m_KeyLen);
}
if (m_Cipher == FXCIPHER_AES) {
m_pAESContext = FX_Alloc(uint8_t, 2048);
@@ -909,7 +909,7 @@
}
m_Cipher = cipher;
m_KeyLen = keylen;
- FXSYS_memcpy32(m_EncryptKey, key, keylen);
+ FXSYS_memcpy(m_EncryptKey, key, keylen);
if (m_Cipher == FXCIPHER_AES) {
m_pAESContext = FX_Alloc(uint8_t, 2048);
}
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
index f0cabe5..c00b193 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
@@ -255,7 +255,7 @@
if (read_size > buf_size) {
read_size = buf_size;
}
- FXSYS_memcpy32(buffer, m_pBuffer->GetBuffer() + m_BufOffset, read_size);
+ FXSYS_memcpy(buffer, m_pBuffer->GetBuffer() + m_BufOffset, read_size);
m_BufOffset += read_size;
if (m_BufOffset == (FX_DWORD)m_pBuffer->GetSize()) {
delete m_pBuffer;
@@ -548,7 +548,7 @@
if (read_size > src_size) {
read_size = src_size;
}
- FXSYS_memcpy32(m_pCurLine + m_LineInSize, src_buf, read_size);
+ FXSYS_memcpy(m_pCurLine + m_LineInSize, src_buf, read_size);
m_LineInSize += read_size;
if (m_LineInSize < m_Pitch) {
break;
@@ -696,7 +696,7 @@
break;
case 2: {
dest_buf.AppendBlock(NULL, m_Count);
- FXSYS_memset8(dest_buf.GetBuffer() + dest_buf.GetSize() - m_Count, byte, m_Count);
+ FXSYS_memset(dest_buf.GetBuffer() + dest_buf.GetSize() - m_Count, byte, m_Count);
m_State = 0;
break;
}
@@ -805,8 +805,8 @@
m_Pitch = (m_nColumns + 7) / 8;
m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
m_pRefBuf = FX_Alloc(uint8_t, m_Pitch);
- FXSYS_memset8(m_pScanlineBuf, 0xff, m_Pitch);
- FXSYS_memset8(m_pRefBuf, 0xff, m_Pitch);
+ FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
+ FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
m_iRow = 0;
m_InputBitPos = 0;
return TRUE;
@@ -851,13 +851,13 @@
return;
}
int start_bitpos = bitpos;
- FXSYS_memset8(m_pScanlineBuf, 0xff, m_Pitch);
+ FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
if (!ReadLine(src_buf, bitsize, bitpos)) {
bitpos = start_bitpos;
return;
}
if (m_Encoding) {
- FXSYS_memcpy32(m_pRefBuf, m_pScanlineBuf, m_Pitch);
+ FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
}
if (m_bBlack) {
for (int i = 0; i < m_Pitch; i ++) {
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
index bfac0e3..3f9f4cc 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
@@ -122,7 +122,7 @@
case PDFOBJ_REFERENCE: {
CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
PARSE_CONTEXT context;
- FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
+ FXSYS_memset(&context, 0, sizeof(PARSE_CONTEXT));
if (pRef->m_pObjList == NULL) {
return 0;
}
@@ -898,7 +898,7 @@
m_GenNum = (FX_DWORD) - 1;
m_pDataBuf = FX_Alloc(uint8_t, size);
if (pData) {
- FXSYS_memcpy32(m_pDataBuf, pData, size);
+ FXSYS_memcpy(m_pDataBuf, pData, size);
}
m_dwSize = size;
if (m_pDict) {
@@ -920,7 +920,7 @@
} else {
m_pDataBuf = FX_Alloc(uint8_t, size);
if (pData) {
- FXSYS_memcpy32(m_pDataBuf, pData, size);
+ FXSYS_memcpy(m_pDataBuf, pData, size);
}
}
m_dwSize = size;
@@ -939,7 +939,7 @@
return m_pFile->ReadBlock(buf, m_FileOffset + offset, size);
}
if (m_pDataBuf) {
- FXSYS_memcpy32(buf, m_pDataBuf + offset, size);
+ FXSYS_memcpy(buf, m_pDataBuf + offset, size);
}
return TRUE;
}
@@ -982,7 +982,7 @@
FX_DWORD actualSize = size > 1024 ? 1024 : size;
m_pFile->ReadBlock(srcBuf, srcOffset, actualSize);
pOther->m_pFile->ReadBlock(destBuf, destOffset, actualSize);
- if (FXSYS_memcmp32(srcBuf, destBuf, actualSize) != 0) {
+ if (FXSYS_memcmp(srcBuf, destBuf, actualSize) != 0) {
return FALSE;
}
size -= actualSize;
@@ -1012,7 +1012,7 @@
while (size > 0) {
FX_DWORD actualSize = std::min(size, 1024U);
pFile->ReadBlock(srcBuf, offset, actualSize);
- if (FXSYS_memcmp32(srcBuf, pBuf, actualSize) != 0) {
+ if (FXSYS_memcmp(srcBuf, pBuf, actualSize) != 0) {
return FALSE;
}
pBuf += actualSize;
@@ -1021,7 +1021,7 @@
}
return TRUE;
}
- return FXSYS_memcmp32(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
+ return FXSYS_memcmp(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
}
CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
{
@@ -1165,7 +1165,7 @@
return p;
}
uint8_t* p = FX_Alloc(uint8_t, m_dwSize);
- FXSYS_memcpy32(p, m_pData, m_dwSize);
+ FXSYS_memcpy(p, m_pData, m_dwSize);
return p;
}
void CPDF_Reference::SetRef(CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
@@ -1234,7 +1234,7 @@
}
if (m_pParser) {
PARSE_CONTEXT context;
- FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
+ FXSYS_memset(&context, 0, sizeof(PARSE_CONTEXT));
context.m_Flags = PDFPARSE_TYPEONLY;
return (int)(uintptr_t)m_pParser->ParseIndirectObject(this, objnum, &context);
}
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
index 4fd7974..ea57729 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
@@ -1024,7 +1024,7 @@
m_pTrailer = (CPDF_Dictionary*)pStream->GetDict()->Clone();
m_CrossRef.SetSize(size);
if (m_V5Type.SetSize(size)) {
- FXSYS_memset32(m_V5Type.GetData(), 0, size);
+ FXSYS_memset(m_V5Type.GetData(), 0, size);
}
} else {
m_Trailers.Add((CPDF_Dictionary*)pStream->GetDict()->Clone());
@@ -1298,7 +1298,7 @@
size = nextoff - thisoff;
}
pBuffer = FX_Alloc(uint8_t, size);
- FXSYS_memcpy32(pBuffer, pData + thisoff + offset, size);
+ FXSYS_memcpy(pBuffer, pData + thisoff + offset, size);
return;
}
n --;
@@ -2445,7 +2445,7 @@
m_Pos = pos.ValueOrDie();
}
GetNextWord();
- if (m_WordSize < 9 || FXSYS_memcmp32(m_WordBuffer, "endstream", 9)) {
+ if (m_WordSize < 9 || FXSYS_memcmp(m_WordBuffer, "endstream", 9)) {
m_Pos = StreamStartPos;
FX_FILESIZE offset = FindTag(FX_BSTRC("endstream"), 0);
if (offset >= 0) {
@@ -2496,7 +2496,7 @@
}
StreamStartPos = m_Pos;
GetNextWord();
- if (m_WordSize == 6 && 0 == FXSYS_memcmp32(m_WordBuffer, "endobj", 6)) {
+ if (m_WordSize == 6 && 0 == FXSYS_memcmp(m_WordBuffer, "endobj", 6)) {
m_Pos = StreamStartPos;
}
return pStream;
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
index 61134f5..0bb0b51 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
@@ -198,7 +198,7 @@
{
int token_len = token.GetLength();
while (m_dwCurPos < m_dwSize - token_len) {
- if (FXSYS_memcmp32(m_pData + m_dwCurPos, token.GetPtr(), token_len) == 0) {
+ if (FXSYS_memcmp(m_pData + m_dwCurPos, token.GetPtr(), token_len) == 0) {
break;
}
m_dwCurPos ++;
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
index a98c57d..10d125a 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
@@ -843,7 +843,7 @@
m_bStopped = bitmap_render.m_bStopped;
if (pSMaskDict) {
CFX_AffineMatrix smask_matrix;
- FXSYS_memcpy32(&smask_matrix, pGeneralState->m_SMaskMatrix, sizeof smask_matrix);
+ FXSYS_memcpy(&smask_matrix, pGeneralState->m_SMaskMatrix, sizeof smask_matrix);
smask_matrix.Concat(*pObj2Device);
CFX_DIBSource* pSMaskSource = LoadSMask(pSMaskDict, &rect, &smask_matrix);
if (pSMaskSource) {
@@ -1217,7 +1217,7 @@
m_TransferFuncMap.SetAt(pObj, pTransferCounter);
static const int kMaxOutputs = 16;
FX_FLOAT output[kMaxOutputs];
- FXSYS_memset32(output, 0, sizeof(output));
+ FXSYS_memset(output, 0, sizeof(output));
FX_FLOAT input;
int noutput;
for (int v = 0; v < 256; v ++) {
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
index 669ba4d..1aa1df1 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
@@ -1020,7 +1020,7 @@
if (!num_floats.IsValid()) {
return NULL;
}
- FXSYS_memset32(pFloats, 0, num_floats.ValueOrDie());
+ FXSYS_memset(pFloats, 0, num_floats.ValueOrDie());
int count = pBC->GetCount() > 8 ? 8 : pBC->GetCount();
for (int i = 0; i < count; i ++) {
pFloats[i] = pBC->GetNumber(i);
@@ -1083,7 +1083,7 @@
dest_buf[i] = pTransfer[src_buf[i]];
}
} else {
- FXSYS_memcpy32(dest_buf, src_buf, dest_pitch * height);
+ FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
}
if (pFunc) {
delete pFunc;
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
index 5851aab..bbb21e2 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
@@ -1102,7 +1102,7 @@
}
if (pSrcLine == NULL) {
uint8_t* pLineBuf = m_pMaskedLine ? m_pMaskedLine : m_pLineBuf;
- FXSYS_memset8(pLineBuf, 0xff, m_Pitch);
+ FXSYS_memset(pLineBuf, 0xff, m_Pitch);
return pLineBuf;
}
if (m_bpc * m_nComponents == 1) {
@@ -1133,13 +1133,13 @@
}
return m_pMaskedLine;
} else {
- FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
+ FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value);
}
return m_pLineBuf;
}
if (m_bpc * m_nComponents <= 8) {
if (m_bpc == 8) {
- FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
+ FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value);
} else {
int src_bit_pos = 0;
for (int col = 0; col < m_Width; col ++) {
@@ -1183,7 +1183,7 @@
pPixel[2] < m_pCompData[2].m_ColorKeyMin || pPixel[2] > m_pCompData[2].m_ColorKeyMax) ? 0xff : 0;
}
} else {
- FXSYS_memset8(m_pMaskedLine, 0xff, m_Pitch);
+ FXSYS_memset(m_pMaskedLine, 0xff, m_Pitch);
}
}
if (m_pColorSpace) {
@@ -1243,7 +1243,7 @@
int orig_Bpp = m_bpc * m_nComponents / 8;
int dest_Bpp = dest_bpp / 8;
if (pSrcLine == NULL) {
- FXSYS_memset32(dest_scan, 0xff, dest_Bpp * clip_width);
+ FXSYS_memset(dest_scan, 0xff, dest_Bpp * clip_width);
return;
}
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
index 2243bff..8a20b46 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
@@ -53,7 +53,7 @@
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
- FXSYS_memset32(pResults, 0, total_results * sizeof(FX_FLOAT));
+ FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
FX_DWORD rgb_array[SHADING_STEPS];
for (int i = 0; i < SHADING_STEPS; i ++) {
FX_FLOAT input = (t_max - t_min) * i / SHADING_STEPS + t_min;
@@ -133,7 +133,7 @@
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
- FXSYS_memset32(pResults, 0, total_results * sizeof(FX_FLOAT));
+ FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
FX_DWORD rgb_array[SHADING_STEPS];
for (int i = 0; i < SHADING_STEPS; i ++) {
FX_FLOAT input = (t_max - t_min) * i / SHADING_STEPS + t_min;
@@ -254,7 +254,7 @@
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
- FXSYS_memset32(pResults, 0, total_results * sizeof(FX_FLOAT));
+ FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
for (int row = 0; row < height; row ++) {
FX_DWORD* dib_buf = (FX_DWORD*)(pBitmap->GetBuffer() + row * pitch);
for (int column = 0; column < width; column ++) {
@@ -386,7 +386,7 @@
return;
}
CPDF_MeshVertex triangle[3];
- FXSYS_memset32(triangle, 0, sizeof(triangle));
+ FXSYS_memset(triangle, 0, sizeof(triangle));
while (!stream.m_BitStream.IsEOF()) {
CPDF_MeshVertex vertex;
@@ -568,7 +568,7 @@
struct Coon_Color {
Coon_Color()
{
- FXSYS_memset32(comp, 0, sizeof(int) * 3);
+ FXSYS_memset(comp, 0, sizeof(int) * 3);
}
int comp[3];
void BiInterpol(Coon_Color colors[4], int x, int y, int x_scale, int y_scale)
@@ -733,11 +733,11 @@
for (i = 0; i < 4; i ++) {
tempCoords[i] = coords[(flag * 3 + i) % 12];
}
- FXSYS_memcpy32(coords, tempCoords, sizeof(CFX_FloatPoint) * 4);
+ FXSYS_memcpy(coords, tempCoords, sizeof(CFX_FloatPoint) * 4);
Coon_Color tempColors[2];
tempColors[0] = patch.patch_colors[flag];
tempColors[1] = patch.patch_colors[(flag + 1) % 4];
- FXSYS_memcpy32(patch.patch_colors, tempColors, sizeof(Coon_Color) * 2);
+ FXSYS_memcpy(patch.patch_colors, tempColors, sizeof(Coon_Color) * 2);
}
for (i = iStartPoint; i < point_count; i ++) {
stream.GetCoords(coords[i].x, coords[i].y);
diff --git a/core/src/fpdfdoc/doc_form.cpp b/core/src/fpdfdoc/doc_form.cpp
index 27432df..c59f938 100644
--- a/core/src/fpdfdoc/doc_form.cpp
+++ b/core/src/fpdfdoc/doc_form.cpp
@@ -139,7 +139,7 @@
for (int i = 0; i < ptr_array.GetSize(); i ++) {
_Node *pNode = (_Node *)ptr_array[i];
if (pNode->short_name.GetLength() == short_name.GetLength() &&
- FXSYS_memcmp32(pNode->short_name.c_str(), short_name.c_str(), short_name.GetLength()*sizeof(FX_WCHAR)) == 0) {
+ FXSYS_memcmp(pNode->short_name.c_str(), short_name.c_str(), short_name.GetLength()*sizeof(FX_WCHAR)) == 0) {
return pNode;
}
}
diff --git a/core/src/fpdftext/fpdf_text_int.cpp b/core/src/fpdftext/fpdf_text_int.cpp
index b100394..a6c32bb 100644
--- a/core/src/fpdftext/fpdf_text_int.cpp
+++ b/core/src/fpdftext/fpdf_text_int.cpp
@@ -1000,8 +1000,8 @@
if (minH >= maxH || minV >= maxV) {
continue;
}
- FXSYS_memset8(pDataH + minH, 1, maxH - minH);
- FXSYS_memset8(pDataV + minV, 1, maxV - minV);
+ FXSYS_memset(pDataH + minH, 1, maxH - minH);
+ FXSYS_memset(pDataV + minV, 1, maxV - minV);
if (fLineHeight <= 0.0f) {
fLineHeight = pPageObj->m_Top - pPageObj->m_Bottom;
}
@@ -2585,7 +2585,7 @@
int nLen = (lpchEnd == NULL) ?
(int)FXSYS_wcslen(lpszFullString) : (int)(lpchEnd - lpszFullString);
ASSERT(nLen >= 0);
- FXSYS_memcpy32(rString.GetBuffer(nLen), lpszFullString, nLen * sizeof(FX_WCHAR));
+ FXSYS_memcpy(rString.GetBuffer(nLen), lpszFullString, nLen * sizeof(FX_WCHAR));
rString.ReleaseBuffer();
return TRUE;
}
diff --git a/core/src/fxcodec/codec/fx_codec.cpp b/core/src/fxcodec/codec/fx_codec.cpp
index 1068126..db95053 100644
--- a/core/src/fxcodec/codec/fx_codec.cpp
+++ b/core/src/fxcodec/codec/fx_codec.cpp
@@ -98,7 +98,7 @@
return NULL;
}
if (m_pDataCache && m_NextLine == m_pDataCache->m_nCachedLines) {
- FXSYS_memcpy32(&m_pDataCache->m_Data + m_NextLine * m_Pitch, pLine, m_Pitch);
+ FXSYS_memcpy(&m_pDataCache->m_Data + m_NextLine * m_Pitch, pLine, m_Pitch);
m_pDataCache->m_nCachedLines ++;
}
return pLine;
@@ -337,7 +337,7 @@
}
FX_BOOL CCodec_RLScanlineDecoder::v_Rewind()
{
- FXSYS_memset32(m_pScanline, 0, m_Pitch);
+ FXSYS_memset(m_pScanline, 0, m_Pitch);
m_SrcOffset = 0;
m_bEOD = FALSE;
m_Operator = 0;
@@ -352,7 +352,7 @@
return NULL;
}
}
- FXSYS_memset32(m_pScanline, 0, m_Pitch);
+ FXSYS_memset(m_pScanline, 0, m_Pitch);
FX_DWORD col_pos = 0;
FX_BOOL eol = FALSE;
while (m_SrcOffset < m_SrcSize && !eol) {
@@ -366,7 +366,7 @@
copy_len = m_SrcSize - m_SrcOffset;
m_bEOD = TRUE;
}
- FXSYS_memcpy32(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
+ FXSYS_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) {
@@ -379,7 +379,7 @@
duplicate_len = m_dwLineBytes - col_pos;
eol = TRUE;
}
- FXSYS_memset8(m_pScanline + col_pos, fill, duplicate_len);
+ FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len);
col_pos += duplicate_len;
UpdateOperator((uint8_t)duplicate_len);
} else {
diff --git a/core/src/fxcodec/codec/fx_codec_fax.cpp b/core/src/fxcodec/codec/fx_codec_fax.cpp
index 4050236..148d3d4 100644
--- a/core/src/fxcodec/codec/fx_codec_fax.cpp
+++ b/core/src/fxcodec/codec/fx_codec_fax.cpp
@@ -130,7 +130,7 @@
dest_buf[last_byte] -= 1 << (7 - i);
}
if (last_byte > first_byte + 1) {
- FXSYS_memset32(dest_buf + first_byte + 1, 0, last_byte - first_byte - 1);
+ FXSYS_memset(dest_buf + first_byte + 1, 0, last_byte - first_byte - 1);
}
}
#define NEXTBIT src_buf[bitpos/8] & (1 << (7-bitpos%8)); bitpos ++;
@@ -633,7 +633,7 @@
}
FX_BOOL CCodec_FaxDecoder::v_Rewind()
{
- FXSYS_memset8(m_pRefBuf, 0xff, m_Pitch);
+ FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
bitpos = 0;
return TRUE;
}
@@ -644,10 +644,10 @@
if (bitpos >= bitsize) {
return NULL;
}
- FXSYS_memset8(m_pScanlineBuf, 0xff, m_Pitch);
+ FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
if (m_Encoding < 0) {
_FaxG4GetRow(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_OrigWidth);
- FXSYS_memcpy32(m_pRefBuf, m_pScanlineBuf, m_Pitch);
+ FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
} else if (m_Encoding == 0) {
_FaxGet1DLine(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_OrigWidth);
} else {
@@ -658,7 +658,7 @@
} else {
_FaxG4GetRow(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_OrigWidth);
}
- FXSYS_memcpy32(m_pRefBuf, m_pScanlineBuf, m_Pitch);
+ FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
}
if (m_bEndOfLine) {
_FaxSkipEOL(m_pSrcBuf, bitsize, bitpos);
@@ -700,13 +700,13 @@
pitch = (width + 7) / 8;
}
uint8_t* ref_buf = FX_Alloc(uint8_t, pitch);
- FXSYS_memset8(ref_buf, 0xff, pitch);
+ FXSYS_memset(ref_buf, 0xff, pitch);
int bitpos = *pbitpos;
for (int iRow = 0; iRow < height; iRow ++) {
uint8_t* line_buf = dest_buf + iRow * pitch;
- FXSYS_memset8(line_buf, 0xff, pitch);
+ FXSYS_memset(line_buf, 0xff, pitch);
_FaxG4GetRow(src_buf, src_size << 3, bitpos, line_buf, ref_buf, width);
- FXSYS_memcpy32(ref_buf, line_buf, pitch);
+ FXSYS_memcpy(ref_buf, line_buf, pitch);
}
FX_Free(ref_buf);
*pbitpos = bitpos;
@@ -938,7 +938,7 @@
m_Rows = height;
m_Pitch = pitch;
m_pRefLine = FX_Alloc(uint8_t, m_Pitch);
- FXSYS_memset8(m_pRefLine, 0xff, m_Pitch);
+ FXSYS_memset(m_pRefLine, 0xff, m_Pitch);
m_pLineBuf = FX_Alloc2D(uint8_t, m_Pitch, 8);
m_DestBuf.EstimateSize(0, 10240);
}
@@ -957,13 +957,13 @@
uint8_t last_byte = 0;
for (int i = 0; i < m_Rows; i ++) {
const uint8_t* scan_line = m_pSrcBuf + i * m_Pitch;
- FXSYS_memset32(m_pLineBuf, 0, m_Pitch * 8);
+ FXSYS_memset(m_pLineBuf, 0, m_Pitch * 8);
m_pLineBuf[0] = last_byte;
_FaxEncode2DLine(m_pLineBuf, dest_bitpos, scan_line, m_pRefLine, m_Cols);
m_DestBuf.AppendBlock(m_pLineBuf, dest_bitpos / 8);
last_byte = m_pLineBuf[dest_bitpos / 8];
dest_bitpos %= 8;
- FXSYS_memcpy32(m_pRefLine, scan_line, m_Pitch);
+ FXSYS_memcpy(m_pRefLine, scan_line, m_Pitch);
}
if (dest_bitpos) {
m_DestBuf.AppendByte(last_byte);
diff --git a/core/src/fxcodec/codec/fx_codec_flate.cpp b/core/src/fxcodec/codec/fx_codec_flate.cpp
index 2e6cf4e..f9925c3 100644
--- a/core/src/fxcodec/codec/fx_codec_flate.cpp
+++ b/core/src/fxcodec/codec/fx_codec_flate.cpp
@@ -26,7 +26,7 @@
if (p == NULL) {
return NULL;
}
- FXSYS_memset32(p, 0, sizeof(z_stream));
+ FXSYS_memset(p, 0, sizeof(z_stream));
p->zalloc = alloc_func;
p->zfree = free_func;
inflateInit(p);
@@ -50,7 +50,7 @@
unsigned int post_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context);
unsigned int written = post_pos - pre_pos;
if (written < dest_size) {
- FXSYS_memset8(dest_buf + written, '\0', dest_size - written);
+ FXSYS_memset(dest_buf + written, '\0', dest_size - written);
}
return ret;
}
@@ -252,7 +252,7 @@
if (move_size * (row + 1) > (int)data_size) {
move_size = data_size - (move_size * row);
}
- FXSYS_memmove32(pDestData + 1, pSrcData, move_size);
+ FXSYS_memmove(pDestData + 1, pSrcData, move_size);
pDestData += (move_size + 1);
pSrcData += move_size;
byte_cnt += move_size;
@@ -330,7 +330,7 @@
int BytesPerPixel = (bpc * nColors + 7) / 8;
uint8_t tag = pSrcData[0];
if (tag == 0) {
- FXSYS_memmove32(pDestData, pSrcData + 1, row_size);
+ FXSYS_memmove(pDestData, pSrcData + 1, row_size);
return;
}
for (int byte = 0; byte < row_size; byte ++) {
@@ -407,7 +407,7 @@
if ((row + 1) * (move_size + 1) > (int)data_size) {
move_size = last_row_size - 1;
}
- FXSYS_memmove32(pDestData, pSrcData + 1, move_size);
+ FXSYS_memmove(pDestData, pSrcData + 1, move_size);
pSrcData += move_size + 1;
pDestData += move_size;
byte_cnt += move_size;
@@ -685,7 +685,7 @@
if (m_Predictor == 2) {
FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns);
- FXSYS_memcpy32(m_pLastLine, m_pScanline, m_PredictPitch);
+ FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch);
} else {
FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps, m_OutputWidth);
@@ -694,7 +694,7 @@
int bytes_to_go = m_Pitch;
int read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
if (read_leftover) {
- FXSYS_memcpy32(m_pScanline, m_pPredictBuffer + m_PredictPitch - m_LeftOver, read_leftover);
+ FXSYS_memcpy(m_pScanline, m_pPredictBuffer + m_PredictPitch - m_LeftOver, read_leftover);
m_LeftOver -= read_leftover;
bytes_to_go -= read_leftover;
}
@@ -702,13 +702,13 @@
if (m_Predictor == 2) {
FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns);
- FXSYS_memcpy32(m_pLastLine, m_pPredictBuffer, m_PredictPitch);
+ FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch);
} else {
FPDFAPI_FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch);
TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent, m_Colors, m_Columns);
}
int read_bytes = m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch;
- FXSYS_memcpy32(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, read_bytes);
+ FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer, read_bytes);
m_LeftOver += m_PredictPitch - read_bytes;
bytes_to_go -= read_bytes;
}
@@ -809,7 +809,7 @@
if (i == result_tmp_bufs.GetSize() - 1) {
tmp_buf_size = last_buf_size;
}
- FXSYS_memcpy32(result_buf + result_pos, tmp_buf, tmp_buf_size);
+ FXSYS_memcpy(result_buf + result_pos, tmp_buf, tmp_buf_size);
result_pos += tmp_buf_size;
FX_Free(result_tmp_bufs[i]);
}
@@ -888,7 +888,7 @@
}
uint8_t* pSrcBuf = NULL;
pSrcBuf = FX_Alloc(uint8_t, src_size);
- FXSYS_memcpy32(pSrcBuf, src_buf, src_size);
+ FXSYS_memcpy(pSrcBuf, src_buf, src_size);
FX_BOOL ret = TRUE;
if (predictor == 2) {
ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
diff --git a/core/src/fxcodec/codec/fx_codec_icc.cpp b/core/src/fxcodec/codec/fx_codec_icc.cpp
index 6fe92ff..26537b5 100644
--- a/core/src/fxcodec/codec/fx_codec_icc.cpp
+++ b/core/src/fxcodec/codec/fx_codec_icc.cpp
@@ -414,7 +414,7 @@
MD5ComputeID(pIccParam->pProfileData, pIccParam->dwProfileSize, ID);
break;
case Icc_PARAMTYPE_PARAM:
- FXSYS_memset32(ID, 0, 16);
+ FXSYS_memset(ID, 0, 16);
switch (pIccParam->ColorSpace) {
case IccCS_Gray:
text.Format("%lf", pIccParam->Gamma);
diff --git a/core/src/fxcodec/codec/fx_codec_jbig.cpp b/core/src/fxcodec/codec/fx_codec_jbig.cpp
index b908915..b50ae64 100644
--- a/core/src/fxcodec/codec/fx_codec_jbig.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jbig.cpp
@@ -8,7 +8,7 @@
#include "codec_int.h"
CCodec_Jbig2Context::CCodec_Jbig2Context()
{
- FXSYS_memset32(this, 0, sizeof(CCodec_Jbig2Context));
+ FXSYS_memset(this, 0, sizeof(CCodec_Jbig2Context));
}
CCodec_Jbig2Module::~CCodec_Jbig2Module()
{
@@ -28,7 +28,7 @@
FX_BOOL CCodec_Jbig2Module::Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch)
{
- FXSYS_memset32(dest_buf, 0, height * dest_pitch);
+ FXSYS_memset(dest_buf, 0, height * dest_pitch);
CJBig2_Context* pContext = CJBig2_Context::CreateContext(&m_Module,
(uint8_t*)global_data, global_size, (uint8_t*)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache);
if (pContext == NULL) {
@@ -97,7 +97,7 @@
m_pJbig2Context->m_dest_pitch = dest_pitch;
m_pJbig2Context->m_pPause = pPause;
m_pJbig2Context->m_bFileReader = FALSE;
- FXSYS_memset32(dest_buf, 0, height * dest_pitch);
+ FXSYS_memset(dest_buf, 0, height * dest_pitch);
m_pJbig2Context->m_pContext = CJBig2_Context::CreateContext(&m_Module,
(uint8_t*)global_data, global_size, (uint8_t*)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache, pPause);
if(!m_pJbig2Context->m_pContext) {
diff --git a/core/src/fxcodec/codec/fx_codec_jpeg.cpp b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
index 4017be5..bb60300 100644
--- a/core/src/fxcodec/codec/fx_codec_jpeg.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
@@ -89,16 +89,16 @@
}
FX_DWORD icc_data_length = JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);
uint8_t* icc_data = FX_Alloc(uint8_t, icc_data_length);
- FXSYS_memcpy32(icc_data, "\x49\x43\x43\x5f\x50\x52\x4f\x46\x49\x4c\x45\x00", 12);
+ FXSYS_memcpy(icc_data, "\x49\x43\x43\x5f\x50\x52\x4f\x46\x49\x4c\x45\x00", 12);
icc_data[13] = (uint8_t)icc_segment_num;
for (uint8_t i = 0; i < (icc_segment_num - 1); i++) {
icc_data[12] = i + 1;
- FXSYS_memcpy32(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + i * icc_segment_size, icc_segment_size);
+ FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + i * icc_segment_size, icc_segment_size);
jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, icc_data_length);
}
icc_data[12] = (uint8_t)icc_segment_num;
FX_DWORD icc_size = (icc_segment_num - 1) * icc_segment_size;
- FXSYS_memcpy32(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size, icc_length - icc_size);
+ FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size, icc_length - icc_size);
jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, JPEG_OVERHEAD_LEN + icc_length - icc_size);
FX_Free(icc_data);
return TRUE;
@@ -312,9 +312,9 @@
m_bInited = FALSE;
m_pExtProvider = NULL;
m_pExtContext = NULL;
- FXSYS_memset32(&cinfo, 0, sizeof(cinfo));
- FXSYS_memset32(&jerr, 0, sizeof(jerr));
- FXSYS_memset32(&src, 0, sizeof(src));
+ FXSYS_memset(&cinfo, 0, sizeof(cinfo));
+ FXSYS_memset(&jerr, 0, sizeof(jerr));
+ FXSYS_memset(&src, 0, sizeof(src));
m_nDefaultScaleDenom = 1;
}
CCodec_JpegDecoder::~CCodec_JpegDecoder()
@@ -388,7 +388,7 @@
src.fill_input_buffer = _src_fill_buffer;
src.resync_to_restart = _src_resync;
m_bJpegTransform = ColorTransform;
- if(src_size > 1 && FXSYS_memcmp32(src_buf + src_size - 2, "\xFF\xD9", 2) != 0) {
+ if(src_size > 1 && FXSYS_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/src/fxcodec/codec/fx_codec_jpx_opj.cpp b/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
index 8895024..7dd91b3 100644
--- a/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
@@ -472,9 +472,9 @@
image->comps[1] = image->comps[0];
image->comps[2] = image->comps[0];
image->comps[1].data = FX_Alloc(int, (size_t)max);
- FXSYS_memset8(image->comps[1].data, 0, sizeof(int) * (size_t)max);
+ FXSYS_memset(image->comps[1].data, 0, sizeof(int) * (size_t)max);
image->comps[2].data = FX_Alloc(int, (size_t)max);
- FXSYS_memset8(image->comps[2].data, 0, sizeof(int) * (size_t)max);
+ FXSYS_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) {
@@ -630,7 +630,7 @@
opj_set_default_decoder_parameters(¶meters);
parameters.decod_format = 0;
parameters.cod_format = 3;
- if(FXSYS_memcmp32(m_SrcData, szJP2Header, sizeof(szJP2Header)) == 0) {
+ if(FXSYS_memcmp(m_SrcData, szJP2Header, sizeof(szJP2Header)) == 0) {
l_codec = opj_create_decompress(OPJ_CODEC_JP2);
parameters.decod_format = 1;
} else {
@@ -707,7 +707,7 @@
if(pitch < (int)(image->comps[0].w * 8 * image->numcomps + 31) >> 5 << 2) {
return FALSE;
}
- FXSYS_memset8(dest_buf, 0xff, image->y1 * pitch);
+ FXSYS_memset(dest_buf, 0xff, image->y1 * pitch);
uint8_t** channel_bufs = FX_Alloc(uint8_t*, image->numcomps);
FX_BOOL result = FALSE;
int* adjust_comps = FX_Alloc(int, image->numcomps);
diff --git a/core/src/fxcodec/fx_zlib/zlib_v128/zutil.h b/core/src/fxcodec/fx_zlib/zlib_v128/zutil.h
index 582d1b5..e4ec2bd 100644
--- a/core/src/fxcodec/fx_zlib/zlib_v128/zutil.h
+++ b/core/src/fxcodec/fx_zlib/zlib_v128/zutil.h
@@ -207,9 +207,9 @@
# define zmemcmp _fmemcmp
# define zmemzero(dest, len) _fmemset(dest, 0, len)
# else
-# define zmemcpy FXSYS_memcpy32
-# define zmemcmp FXSYS_memcmp32
-# define zmemzero(dest, len) FXSYS_memset32(dest, 0, len)
+# define zmemcpy FXSYS_memcpy
+# define zmemcmp FXSYS_memcmp
+# define zmemzero(dest, len) FXSYS_memset(dest, 0, len)
# endif
#else
void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
diff --git a/core/src/fxcodec/jbig2/JBig2_Define.h b/core/src/fxcodec/jbig2/JBig2_Define.h
index cc1e390..f3bdd5a 100644
--- a/core/src/fxcodec/jbig2/JBig2_Define.h
+++ b/core/src/fxcodec/jbig2/JBig2_Define.h
@@ -7,9 +7,9 @@
#ifndef _JBIG2_DEFINE_H_
#define _JBIG2_DEFINE_H_
#include "../../../include/fxcrt/fx_system.h"
-#define JBIG2_memset FXSYS_memset8
-#define JBIG2_memcmp FXSYS_memcmp32
-#define JBIG2_memcpy FXSYS_memcpy32
+#define JBIG2_memset FXSYS_memset
+#define JBIG2_memcmp FXSYS_memcmp
+#define JBIG2_memcpy FXSYS_memcpy
#include "JBig2_Object.h"
#define JBIG2_OOB 1
typedef struct {
diff --git a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
index bad595e..929180e 100644
--- a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
@@ -2376,7 +2376,7 @@
}
JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((uint8_t)nTmp));
SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJBig2_Image*));
- FXSYS_memset32(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));
+ FXSYS_memset(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));
HCHEIGHT = 0;
NSYMSDECODED = 0;
while(NSYMSDECODED < SDNUMNEWSYMS) {
@@ -2699,12 +2699,12 @@
CJBig2_SymbolDict *pDict;
JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJBig2_Image*));
- FXSYS_memset32(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));
+ FXSYS_memset(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));
SDNEWSYMWIDTHS = NULL;
BHC = NULL;
if(SDREFAGG == 0) {
SDNEWSYMWIDTHS = (FX_DWORD *)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD));
- FXSYS_memset32(SDNEWSYMWIDTHS, 0 , SDNUMNEWSYMS * sizeof(FX_DWORD));
+ FXSYS_memset(SDNEWSYMWIDTHS, 0 , SDNUMNEWSYMS * sizeof(FX_DWORD));
}
HCHEIGHT = 0;
NSYMSDECODED = 0;
diff --git a/core/src/fxcodec/lcms2/lcms2-2.6/src/cmserr.c b/core/src/fxcodec/lcms2/lcms2-2.6/src/cmserr.c
index 964182a..a32b6e2 100644
--- a/core/src/fxcodec/lcms2/lcms2-2.6/src/cmserr.c
+++ b/core/src/fxcodec/lcms2/lcms2-2.6/src/cmserr.c
@@ -269,7 +269,7 @@
void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
{
void* p = FXMEM_DefaultAlloc(size, 1);
- if (p) FXSYS_memset32(p, 0, size);
+ if (p) FXSYS_memset(p, 0, size);
return p;
}
@@ -299,7 +299,7 @@
void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
{
void* p = FXMEM_DefaultAlloc(size, 1);
- FXSYS_memmove32(p, Org, size);
+ FXSYS_memmove(p, Org, size);
return p;
}
diff --git a/core/src/fxcodec/libjpeg/jinclude.h b/core/src/fxcodec/libjpeg/jinclude.h
index 0c7aa68..5cfc6e1 100644
--- a/core/src/fxcodec/libjpeg/jinclude.h
+++ b/core/src/fxcodec/libjpeg/jinclude.h
@@ -75,8 +75,8 @@
#else /* not BSD, assume ANSI/SysV string lib */
//#include <string.h>
-#define MEMZERO(target,size) FXSYS_memset32((void *)(target), 0, (size_t)(size))
-#define MEMCOPY(dest,src,size) FXSYS_memcpy32((void *)(dest), (const void *)(src), (size_t)(size))
+#define MEMZERO(target,size) FXSYS_memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size) FXSYS_memcpy((void *)(dest), (const void *)(src), (size_t)(size))
#endif
diff --git a/core/src/fxcrt/extension.h b/core/src/fxcrt/extension.h
index 4c270db..79efa0e 100644
--- a/core/src/fxcrt/extension.h
+++ b/core/src/fxcrt/extension.h
@@ -240,7 +240,7 @@
m_nCurPos = newPos.ValueOrDie();
if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
- FXSYS_memcpy32(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
+ FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
return TRUE;
}
size_t nStartBlock = (size_t)offset / m_nGrowSize;
@@ -250,7 +250,7 @@
if (nRead > size) {
nRead = size;
}
- FXSYS_memcpy32(buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
+ FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
buffer = ((uint8_t*)buffer) + nRead;
size -= nRead;
nStartBlock ++;
@@ -303,7 +303,7 @@
return FALSE;
}
}
- FXSYS_memcpy32((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
+ FXSYS_memcpy((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
if (m_nCurSize < m_nCurPos) {
m_nCurSize = m_nCurPos;
}
@@ -327,7 +327,7 @@
if (nWrite > size) {
nWrite = size;
}
- FXSYS_memcpy32((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite);
+ FXSYS_memcpy((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite);
buffer = ((uint8_t*)buffer) + nWrite;
size -= nWrite;
nStartBlock ++;
diff --git a/core/src/fxcrt/fx_basic_array.cpp b/core/src/fxcrt/fx_basic_array.cpp
index d21909f..56b2f57 100644
--- a/core/src/fxcrt/fx_basic_array.cpp
+++ b/core/src/fxcrt/fx_basic_array.cpp
@@ -42,7 +42,7 @@
m_nSize = m_nMaxSize = nNewSize;
} else if (nNewSize <= m_nMaxSize) {
if (nNewSize > m_nSize) {
- FXSYS_memset32(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
+ FXSYS_memset(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
}
m_nSize = nNewSize;
} else {
@@ -56,7 +56,7 @@
if (pNewData == NULL) {
return FALSE;
}
- FXSYS_memset32(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
+ FXSYS_memset(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
@@ -72,7 +72,7 @@
return FALSE;
}
- FXSYS_memcpy32(m_pData + nOldSize * m_nUnitSize, src.m_pData, src.m_nSize * m_nUnitSize);
+ FXSYS_memcpy(m_pData + nOldSize * m_nUnitSize, src.m_pData, src.m_nSize * m_nUnitSize);
return TRUE;
}
FX_BOOL CFX_BasicArray::Copy(const CFX_BasicArray& src)
@@ -80,7 +80,7 @@
if (!SetSize(src.m_nSize)) {
return FALSE;
}
- FXSYS_memcpy32(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);
+ FXSYS_memcpy(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);
return TRUE;
}
uint8_t* CFX_BasicArray::InsertSpaceAt(int nIndex, int nCount)
@@ -97,9 +97,9 @@
if (!SetSize(m_nSize + nCount)) {
return NULL;
}
- FXSYS_memmove32(m_pData + (nIndex + nCount)*m_nUnitSize, m_pData + nIndex * m_nUnitSize,
+ FXSYS_memmove(m_pData + (nIndex + nCount)*m_nUnitSize, m_pData + nIndex * m_nUnitSize,
(nOldSize - nIndex) * m_nUnitSize);
- FXSYS_memset32(m_pData + nIndex * m_nUnitSize, 0, nCount * m_nUnitSize);
+ FXSYS_memset(m_pData + nIndex * m_nUnitSize, 0, nCount * m_nUnitSize);
}
return m_pData + nIndex * m_nUnitSize;
}
@@ -110,7 +110,7 @@
}
int nMoveCount = m_nSize - (nIndex + nCount);
if (nMoveCount) {
- FXSYS_memmove32(m_pData + nIndex * m_nUnitSize, m_pData + (nIndex + nCount) * m_nUnitSize, nMoveCount * m_nUnitSize);
+ FXSYS_memmove(m_pData + nIndex * m_nUnitSize, m_pData + (nIndex + nCount) * m_nUnitSize, nMoveCount * m_nUnitSize);
}
m_nSize -= nCount;
return TRUE;
@@ -126,7 +126,7 @@
if (!InsertSpaceAt(nStartIndex, pNewArray->m_nSize)) {
return FALSE;
}
- FXSYS_memcpy32(m_pData + nStartIndex * m_nUnitSize, pNewArray->m_pData, pNewArray->m_nSize * m_nUnitSize);
+ FXSYS_memcpy(m_pData + nStartIndex * m_nUnitSize, pNewArray->m_pData, pNewArray->m_nSize * m_nUnitSize);
return TRUE;
}
const void* CFX_BasicArray::GetDataPtr(int index) const
diff --git a/core/src/fxcrt/fx_basic_bstring.cpp b/core/src/fxcrt/fx_basic_bstring.cpp
index c6fa998..9f54414 100644
--- a/core/src/fxcrt/fx_basic_bstring.cpp
+++ b/core/src/fxcrt/fx_basic_bstring.cpp
@@ -89,7 +89,7 @@
if (nLen) {
m_pData = StringData::Create(nLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, lpsz, nLen);
+ FXSYS_memcpy(m_pData->m_String, lpsz, nLen);
}
} else {
m_pData = NULL;
@@ -100,7 +100,7 @@
if (nLen > 0) {
m_pData = StringData::Create(nLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, lpsz, nLen);
+ FXSYS_memcpy(m_pData->m_String, lpsz, nLen);
}
} else {
m_pData = NULL;
@@ -146,8 +146,8 @@
}
m_pData = StringData::Create(nNewLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, str1.GetCStr(), str1.GetLength());
- FXSYS_memcpy32(m_pData->m_String + str1.GetLength(), str2.GetCStr(), str2.GetLength());
+ FXSYS_memcpy(m_pData->m_String, str1.GetCStr(), str1.GetLength());
+ FXSYS_memcpy(m_pData->m_String + str1.GetLength(), str2.GetCStr(), str2.GetLength());
}
}
const CFX_ByteString& CFX_ByteString::operator=(const FX_CHAR* lpsz)
@@ -198,7 +198,7 @@
if (len) {
m_pData = StringData::Create(len);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, buf, len);
+ FXSYS_memcpy(m_pData->m_String, buf, len);
}
} else {
m_pData = NULL;
@@ -241,7 +241,7 @@
return m_pData->m_nDataLength == 0;
}
return FXSYS_strlen(ptr) == m_pData->m_nDataLength &&
- FXSYS_memcmp32(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0;
+ FXSYS_memcmp(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0;
}
bool CFX_ByteString::Equal(const CFX_ByteStringC& str) const
{
@@ -249,7 +249,7 @@
return str.IsEmpty();
}
return m_pData->m_nDataLength == str.GetLength() &&
- FXSYS_memcmp32(m_pData->m_String, str.GetCStr(), str.GetLength()) == 0;
+ FXSYS_memcmp(m_pData->m_String, str.GetCStr(), str.GetLength()) == 0;
}
bool CFX_ByteString::Equal(const CFX_ByteString& other) const
{
@@ -260,7 +260,7 @@
return false;
}
return other.m_pData->m_nDataLength == m_pData->m_nDataLength &&
- FXSYS_memcmp32(other.m_pData->m_String,
+ FXSYS_memcmp(other.m_pData->m_String,
m_pData->m_String,
m_pData->m_nDataLength) == 0;
}
@@ -304,7 +304,7 @@
void CFX_ByteString::AssignCopy(FX_STRSIZE nSrcLen, const FX_CHAR* lpszSrcData)
{
AllocBeforeWrite(nSrcLen);
- FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen);
+ FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen);
m_pData->m_nDataLength = nSrcLen;
m_pData->m_String[nSrcLen] = 0;
}
@@ -318,7 +318,7 @@
FX_STRSIZE nDataLength = pData->m_nDataLength;
m_pData = StringData::Create(nDataLength);
if (m_pData != NULL) {
- FXSYS_memcpy32(m_pData->m_String, pData->m_String, nDataLength + 1);
+ FXSYS_memcpy(m_pData->m_String, pData->m_String, nDataLength + 1);
}
}
void CFX_ByteString::AllocBeforeWrite(FX_STRSIZE nLen)
@@ -377,7 +377,7 @@
if (!m_pData) {
return NULL;
}
- FXSYS_memcpy32(m_pData->m_String, pOldData->m_String, (nOldLen + 1));
+ FXSYS_memcpy(m_pData->m_String, pOldData->m_String, (nOldLen + 1));
m_pData->m_nDataLength = nOldLen;
pOldData->Release();
return m_pData->m_String;
@@ -399,7 +399,7 @@
}
CopyBeforeWrite();
int nBytesToCopy = nOldLength - mLength + 1;
- FXSYS_memmove32(m_pData->m_String + nIndex,
+ FXSYS_memmove(m_pData->m_String + nIndex,
m_pData->m_String + mLength, nBytesToCopy);
m_pData->m_nDataLength = nOldLength - nCount;
}
@@ -415,13 +415,13 @@
if (!m_pData) {
return;
}
- FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen);
+ FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen);
return;
}
if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
} else {
- FXSYS_memcpy32(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen);
+ FXSYS_memcpy(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen);
m_pData->m_nDataLength += nSrcLen;
m_pData->m_String[m_pData->m_nDataLength] = 0;
}
@@ -480,7 +480,7 @@
ASSERT(dest.m_pData == NULL);
dest.m_pData = StringData::Create(nCopyLen);
if (dest.m_pData) {
- FXSYS_memcpy32(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, nCopyLen);
+ FXSYS_memcpy(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, nCopyLen);
}
}
#define FORCE_ANSI 0x10000
@@ -726,13 +726,13 @@
return 0;
}
if(pOldData != NULL) {
- FXSYS_memmove32(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1));
+ FXSYS_memmove(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1));
pOldData->Release();
} else {
m_pData->m_String[0] = 0;
}
}
- FXSYS_memmove32(m_pData->m_String + nIndex + 1,
+ FXSYS_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;
@@ -911,13 +911,13 @@
FX_CHAR* pDest = pNewData->m_String;
for (FX_STRSIZE i = 0; i < nCount; i ++) {
const FX_CHAR* pTarget = FX_strstr(pStart, (FX_STRSIZE)(pEnd - pStart), lpszOld.GetCStr(), nSourceLen);
- FXSYS_memcpy32(pDest, pStart, pTarget - pStart);
+ FXSYS_memcpy(pDest, pStart, pTarget - pStart);
pDest += pTarget - pStart;
- FXSYS_memcpy32(pDest, lpszNew.GetCStr(), lpszNew.GetLength());
+ FXSYS_memcpy(pDest, lpszNew.GetCStr(), lpszNew.GetLength());
pDest += lpszNew.GetLength();
pStart = pTarget + nSourceLen;
}
- FXSYS_memcpy32(pDest, pStart, pEnd - pStart);
+ FXSYS_memcpy(pDest, pStart, pEnd - pStart);
m_pData->Release();
m_pData = pNewData;
return nCount;
@@ -1041,7 +1041,7 @@
}
if (pos) {
FX_STRSIZE nDataLength = len - pos;
- FXSYS_memmove32(m_pData->m_String, m_pData->m_String + pos, (nDataLength + 1)*sizeof(FX_CHAR));
+ FXSYS_memmove(m_pData->m_String, m_pData->m_String + pos, (nDataLength + 1)*sizeof(FX_CHAR));
m_pData->m_nDataLength = nDataLength;
}
}
@@ -1110,7 +1110,7 @@
int i = scaled / scale;
FXSYS_itoa(i, buf2, 10);
FX_STRSIZE len = FXSYS_strlen(buf2);
- FXSYS_memcpy32(buf + buf_size, buf2, len);
+ FXSYS_memcpy(buf + buf_size, buf2, len);
buf_size += len;
int fraction = scaled % scale;
if (fraction == 0) {
diff --git a/core/src/fxcrt/fx_basic_buffer.cpp b/core/src/fxcrt/fx_basic_buffer.cpp
index 43da8e9..9fc400e 100644
--- a/core/src/fxcrt/fx_basic_buffer.cpp
+++ b/core/src/fxcrt/fx_basic_buffer.cpp
@@ -31,7 +31,7 @@
if (!m_pBuffer || start_index < 0 || start_index + count > m_DataSize) {
return;
}
- FXSYS_memmove32(m_pBuffer + start_index, m_pBuffer + start_index + count, m_DataSize - start_index - count);
+ FXSYS_memmove(m_pBuffer + start_index, m_pBuffer + start_index + count, m_DataSize - start_index - count);
m_DataSize -= count;
}
void CFX_BinaryBuf::Clear()
@@ -103,14 +103,14 @@
if (!m_pBuffer) {
return;
}
- FXSYS_memcpy32(m_pBuffer, pStr, size);
+ FXSYS_memcpy(m_pBuffer, pStr, size);
m_DataSize = size;
}
void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size)
{
ExpandBuf(size);
if (pBuf && m_pBuffer) {
- FXSYS_memcpy32(m_pBuffer + m_DataSize, pBuf, size);
+ FXSYS_memcpy(m_pBuffer + m_DataSize, pBuf, size);
}
m_DataSize += size;
}
@@ -120,9 +120,9 @@
if (!m_pBuffer) {
return;
}
- FXSYS_memmove32(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);
+ FXSYS_memmove(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);
if (pBuf) {
- FXSYS_memcpy32(m_pBuffer + pos, pBuf, size);
+ FXSYS_memcpy(m_pBuffer + pos, pBuf, size);
}
m_DataSize += size;
}
@@ -132,7 +132,7 @@
if (!m_pBuffer) {
return;
}
- FXSYS_memset8(m_pBuffer + m_DataSize, byte, count);
+ FXSYS_memset(m_pBuffer + m_DataSize, byte, count);
m_DataSize += count;
}
CFX_ByteStringC CFX_BinaryBuf::GetByteString() const
@@ -360,7 +360,7 @@
return *this;
}
FX_CHAR* buffer = str.GetBuffer(len);
- FXSYS_memcpy32(buffer, m_pLoadingBuf + m_LoadingPos, len);
+ FXSYS_memcpy(buffer, m_pLoadingBuf + m_LoadingPos, len);
str.ReleaseBuffer(len);
m_LoadingPos += len;
return *this;
@@ -377,7 +377,7 @@
if (m_LoadingPos + dwSize > m_LoadingSize) {
return FALSE;
}
- FXSYS_memcpy32(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);
+ FXSYS_memcpy(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);
m_LoadingPos += dwSize;
return TRUE;
}
@@ -459,7 +459,7 @@
FX_STRSIZE temp_size = (FX_STRSIZE)size;
while (temp_size > 0) {
FX_STRSIZE buf_size = FX_MIN(m_BufSize - m_Length, (FX_STRSIZE)temp_size);
- FXSYS_memcpy32(m_pBuffer + m_Length, buffer, buf_size);
+ FXSYS_memcpy(m_pBuffer + m_Length, buffer, buf_size);
m_Length += buf_size;
if (m_Length == m_BufSize) {
if (!Flush()) {
diff --git a/core/src/fxcrt/fx_basic_maps.cpp b/core/src/fxcrt/fx_basic_maps.cpp
index afc7c82..8a886f8 100644
--- a/core/src/fxcrt/fx_basic_maps.cpp
+++ b/core/src/fxcrt/fx_basic_maps.cpp
@@ -395,25 +395,25 @@
if (pCompact->m_CompactLen != len) {
return FALSE;
}
- return FXSYS_memcmp32(&pCompact->m_LenHigh, pStr, len) == 0;
+ return FXSYS_memcmp(&pCompact->m_LenHigh, pStr, len) == 0;
}
if (pCompact->m_CompactLen != 0xff || pCompact->m_LenHigh * 256 + pCompact->m_LenLow != len) {
return FALSE;
}
- return FXSYS_memcmp32(pCompact->m_pBuffer, pStr, len) == 0;
+ return FXSYS_memcmp(pCompact->m_pBuffer, pStr, len) == 0;
}
static void _CompactStringStore(_CompactString* pCompact, const uint8_t* pStr, int len)
{
if (len < (int)sizeof(_CompactString)) {
pCompact->m_CompactLen = (uint8_t)len;
- FXSYS_memcpy32(&pCompact->m_LenHigh, pStr, len);
+ FXSYS_memcpy(&pCompact->m_LenHigh, pStr, len);
return;
}
pCompact->m_CompactLen = 0xff;
pCompact->m_LenHigh = len / 256;
pCompact->m_LenLow = len % 256;
pCompact->m_pBuffer = FX_Alloc(uint8_t, len);
- FXSYS_memcpy32(pCompact->m_pBuffer, pStr, len);
+ FXSYS_memcpy(pCompact->m_pBuffer, pStr, len);
}
static CFX_ByteStringC _CompactStringGet(_CompactString* pCompact)
{
diff --git a/core/src/fxcrt/fx_basic_wstring.cpp b/core/src/fxcrt/fx_basic_wstring.cpp
index 1108a3c..2442dae 100644
--- a/core/src/fxcrt/fx_basic_wstring.cpp
+++ b/core/src/fxcrt/fx_basic_wstring.cpp
@@ -63,7 +63,7 @@
if (nLen) {
m_pData = StringData::Create(nLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, lpsz, nLen * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, lpsz, nLen * sizeof(FX_WCHAR));
}
} else {
m_pData = NULL;
@@ -84,7 +84,7 @@
}
m_pData = StringData::Create(str.GetLength());
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, str.GetPtr(), str.GetLength()*sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, str.GetPtr(), str.GetLength()*sizeof(FX_WCHAR));
}
}
CFX_WideString::CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2)
@@ -96,8 +96,8 @@
}
m_pData = StringData::Create(nNewLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, str1.GetPtr(), str1.GetLength()*sizeof(FX_WCHAR));
- FXSYS_memcpy32(m_pData->m_String + str1.GetLength(), str2.GetPtr(), str2.GetLength()*sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, str1.GetPtr(), str1.GetLength()*sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String + str1.GetLength(), str2.GetPtr(), str2.GetLength()*sizeof(FX_WCHAR));
}
}
void CFX_WideString::ReleaseBuffer(FX_STRSIZE nNewLength)
@@ -229,14 +229,14 @@
if (m_pData == NULL) {
m_pData = StringData::Create(nSrcLen);
if (m_pData) {
- FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
}
return;
}
if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
} else {
- FXSYS_memcpy32(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
m_pData->m_nDataLength += nSrcLen;
m_pData->m_String[m_pData->m_nDataLength] = 0;
}
@@ -267,7 +267,7 @@
FX_STRSIZE nDataLength = pData->m_nDataLength;
m_pData = StringData::Create(nDataLength);
if (m_pData != NULL) {
- FXSYS_memcpy32(m_pData->m_String, pData->m_String, (nDataLength + 1) * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, pData->m_String, (nDataLength + 1) * sizeof(FX_WCHAR));
}
}
void CFX_WideString::AllocBeforeWrite(FX_STRSIZE nLen)
@@ -281,7 +281,7 @@
void CFX_WideString::AssignCopy(FX_STRSIZE nSrcLen, const FX_WCHAR* lpszSrcData)
{
AllocBeforeWrite(nSrcLen);
- FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
m_pData->m_nDataLength = nSrcLen;
m_pData->m_String[nSrcLen] = 0;
}
@@ -351,7 +351,7 @@
if (!m_pData) {
return NULL;
}
- FXSYS_memcpy32(m_pData->m_String, pOldData->m_String, (nOldLen + 1)*sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, pOldData->m_String, (nOldLen + 1)*sizeof(FX_WCHAR));
m_pData->m_nDataLength = nOldLen;
pOldData->Release();
return m_pData->m_String;
@@ -410,7 +410,7 @@
ASSERT(dest.m_pData == NULL);
dest.m_pData = StringData::Create(nCopyLen);
if (dest.m_pData) {
- FXSYS_memcpy32(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, iSize.ValueOrDie());
+ FXSYS_memcpy(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, iSize.ValueOrDie());
}
}
CFX_WideString CFX_WideString::Left(FX_STRSIZE nCount) const
@@ -609,7 +609,7 @@
}
if (lpsz != m_pData->m_String) {
int nDataLength = m_pData->m_nDataLength - (FX_STRSIZE)(lpsz - m_pData->m_String);
- FXSYS_memmove32(m_pData->m_String, lpsz, (nDataLength + 1)*sizeof(FX_WCHAR));
+ FXSYS_memmove(m_pData->m_String, lpsz, (nDataLength + 1)*sizeof(FX_WCHAR));
m_pData->m_nDataLength = nDataLength;
}
}
@@ -656,7 +656,7 @@
if (!m_pData) {
return 0;
}
- FXSYS_memcpy32(m_pData->m_String, pstr, pOldData->m_nDataLength * sizeof(FX_WCHAR));
+ FXSYS_memcpy(m_pData->m_String, pstr, pOldData->m_nDataLength * sizeof(FX_WCHAR));
pOldData->Release();
}
lpszStart = m_pData->m_String;
@@ -664,8 +664,8 @@
{
while ((lpszTarget = (FX_WCHAR*)FXSYS_wcsstr(lpszStart, lpszOld)) != NULL && lpszStart < lpszEnd) {
FX_STRSIZE nBalance = nOldLength - (FX_STRSIZE)(lpszTarget - m_pData->m_String + nSourceLen);
- FXSYS_memmove32(lpszTarget + nReplacementLen, lpszTarget + nSourceLen, nBalance * sizeof(FX_WCHAR));
- FXSYS_memcpy32(lpszTarget, lpszNew, nReplacementLen * sizeof(FX_WCHAR));
+ FXSYS_memmove(lpszTarget + nReplacementLen, lpszTarget + nSourceLen, nBalance * sizeof(FX_WCHAR));
+ FXSYS_memcpy(lpszTarget, lpszNew, nReplacementLen * sizeof(FX_WCHAR));
lpszStart = lpszTarget + nReplacementLen;
lpszStart[nBalance] = 0;
nOldLength += (nReplacementLen - nSourceLen);
@@ -695,13 +695,13 @@
return 0;
}
if(pOldData != NULL) {
- FXSYS_memmove32(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1)*sizeof(FX_WCHAR));
+ FXSYS_memmove(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1)*sizeof(FX_WCHAR));
pOldData->Release();
} else {
m_pData->m_String[0] = 0;
}
}
- FXSYS_memmove32(m_pData->m_String + nIndex + 1,
+ FXSYS_memmove(m_pData->m_String + nIndex + 1,
m_pData->m_String + nIndex, (nNewLength - nIndex)*sizeof(FX_WCHAR));
m_pData->m_String[nIndex] = ch;
m_pData->m_nDataLength = nNewLength;
@@ -719,7 +719,7 @@
if (nCount > 0 && nIndex < nOldLength) {
CopyBeforeWrite();
int nBytesToCopy = nOldLength - (nIndex + nCount) + 1;
- FXSYS_memmove32(m_pData->m_String + nIndex,
+ FXSYS_memmove(m_pData->m_String + nIndex,
m_pData->m_String + nIndex + nCount, nBytesToCopy * sizeof(FX_WCHAR));
m_pData->m_nDataLength = nOldLength - nCount;
}
diff --git a/core/src/fxcrt/fx_extension.cpp b/core/src/fxcrt/fx_extension.cpp
index 301ba53..98f70cb 100644
--- a/core/src/fxcrt/fx_extension.cpp
+++ b/core/src/fxcrt/fx_extension.cpp
@@ -344,7 +344,7 @@
::GetSystemTime(&st1);
do {
::GetSystemTime(&st2);
- } while (FXSYS_memcmp32(&st1, &st2, sizeof(SYSTEMTIME)) == 0);
+ } while (FXSYS_memcmp(&st1, &st2, sizeof(SYSTEMTIME)) == 0);
FX_DWORD dwHash1 = FX_HashCode_String_GetA((const FX_CHAR*)&st1, sizeof(st1), TRUE);
FX_DWORD dwHash2 = FX_HashCode_String_GetA((const FX_CHAR*)&st2, sizeof(st2), TRUE);
::srand((dwHash1 << 16) | (FX_DWORD)dwHash2);
diff --git a/core/src/fxcrt/fxcrt_posix.cpp b/core/src/fxcrt/fxcrt_posix.cpp
index 4f58c10..90d77fe 100644
--- a/core/src/fxcrt/fxcrt_posix.cpp
+++ b/core/src/fxcrt/fxcrt_posix.cpp
@@ -65,7 +65,7 @@
return 0;
}
struct stat s;
- FXSYS_memset32(&s, 0, sizeof(s));
+ FXSYS_memset(&s, 0, sizeof(s));
fstat(m_nFD, &s);
return s.st_size;
}
diff --git a/core/src/fxge/agg/agg23/agg_scanline_u.h b/core/src/fxge/agg/agg23/agg_scanline_u.h
index 5b13290..2100115 100644
--- a/core/src/fxge/agg/agg23/agg_scanline_u.h
+++ b/core/src/fxge/agg/agg23/agg_scanline_u.h
@@ -97,7 +97,7 @@
void add_span(int x, unsigned len, unsigned cover)
{
x -= m_min_x;
- FXSYS_memset8(m_covers + x, cover, len);
+ FXSYS_memset(m_covers + x, cover, len);
if(x == m_last_x + 1) {
m_cur_span->len += (coord_type)len;
} else {
diff --git a/core/src/fxge/agg/agg23/fx_agg_path_storage.cpp b/core/src/fxge/agg/agg23/fx_agg_path_storage.cpp
index b62d4ba..8a87621 100644
--- a/core/src/fxge/agg/agg23/fx_agg_path_storage.cpp
+++ b/core/src/fxge/agg/agg23/fx_agg_path_storage.cpp
@@ -55,10 +55,10 @@
unsigned char** new_cmds =
(unsigned char**)(new_coords + m_max_blocks + block_pool);
if(m_coord_blocks) {
- FXSYS_memcpy32(new_coords,
+ FXSYS_memcpy(new_coords,
m_coord_blocks,
m_max_blocks * sizeof(FX_FLOAT*));
- FXSYS_memcpy32(new_cmds,
+ FXSYS_memcpy(new_cmds,
m_cmd_blocks,
m_max_blocks * sizeof(unsigned char*));
FX_Free(m_coord_blocks);
diff --git a/core/src/fxge/agg/agg23/fx_agg_rasterizer_scanline_aa.cpp b/core/src/fxge/agg/agg23/fx_agg_rasterizer_scanline_aa.cpp
index 1c32d96..b26e259 100644
--- a/core/src/fxge/agg/agg23/fx_agg_rasterizer_scanline_aa.cpp
+++ b/core/src/fxge/agg/agg23/fx_agg_rasterizer_scanline_aa.cpp
@@ -118,7 +118,7 @@
if(m_num_blocks >= m_max_blocks) {
cell_aa** new_cells = FX_Alloc( cell_aa*, m_max_blocks + cell_block_pool);
if(m_cells) {
- FXSYS_memcpy32(new_cells, m_cells, m_max_blocks * sizeof(cell_aa*));
+ FXSYS_memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_aa*));
FX_Free(m_cells);
}
m_cells = new_cells;
diff --git a/core/src/fxge/android/fpf_skiafontmgr.cpp b/core/src/fxge/android/fpf_skiafontmgr.cpp
index 0851a93..46923cc 100644
--- a/core/src/fxge/android/fpf_skiafontmgr.cpp
+++ b/core/src/fxge/android/fpf_skiafontmgr.cpp
@@ -373,7 +373,7 @@
return NULL;
}
FXFT_StreamRec streamRec;
- FXSYS_memset32(&streamRec, 0, sizeof(FXFT_StreamRec));
+ FXSYS_memset(&streamRec, 0, sizeof(FXFT_StreamRec));
streamRec.size = pFileRead->GetSize();
streamRec.descriptor.pointer = pFileRead;
streamRec.read = FPF_SkiaStream_Read;
diff --git a/core/src/fxge/android/fpf_skiafontmgr.h b/core/src/fxge/android/fpf_skiafontmgr.h
index 5acf14e..7b7f137 100644
--- a/core/src/fxge/android/fpf_skiafontmgr.h
+++ b/core/src/fxge/android/fpf_skiafontmgr.h
@@ -33,7 +33,7 @@
}
int32_t iSize = FXSYS_strlen(pFamily);
m_pFamily = FX_Alloc(FX_CHAR, iSize + 1);
- FXSYS_memcpy32(m_pFamily, pFamily, iSize * sizeof(FX_CHAR));
+ FXSYS_memcpy(m_pFamily, pFamily, iSize * sizeof(FX_CHAR));
m_pFamily[iSize] = 0;
}
FX_CHAR* m_pFamily;
@@ -63,7 +63,7 @@
}
int32_t iSize = FXSYS_strlen(pPath);
m_pPath = FX_Alloc(FX_CHAR, iSize + 1);
- FXSYS_memcpy32(m_pPath, pPath, iSize * sizeof(FX_CHAR));
+ FXSYS_memcpy(m_pPath, pPath, iSize * sizeof(FX_CHAR));
m_pPath[iSize] = 0;
}
FX_CHAR* m_pPath;
diff --git a/core/src/fxge/dib/fx_dib_composite.cpp b/core/src/fxge/dib/fx_dib_composite.cpp
index aeee91b..b2a72253 100644
--- a/core/src/fxge/dib/fx_dib_composite.cpp
+++ b/core/src/fxge/dib/fx_dib_composite.cpp
@@ -297,7 +297,7 @@
clip_scan ++;
}
} else {
- FXSYS_memset8(dest_scan, 0xff, width);
+ FXSYS_memset(dest_scan, 0xff, width);
}
}
void _CompositeRow_Argb2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count, int blend_type, const uint8_t* clip_scan,
@@ -1331,7 +1331,7 @@
inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int dest_Bpp, int src_Bpp)
{
if (dest_Bpp == src_Bpp) {
- FXSYS_memcpy32(dest_scan, src_scan, width * dest_Bpp);
+ FXSYS_memcpy(dest_scan, src_scan, width * dest_Bpp);
return;
}
for (int col = 0; col < width; col ++) {
@@ -3662,7 +3662,7 @@
int palsize = 1 << (src_format & 0xff);
pDestPalette = FX_Alloc(FX_DWORD, palsize);
if (isDstCmyk == isSrcCmyk) {
- FXSYS_memcpy32(pDestPalette, pSrcPalette, palsize * sizeof(FX_DWORD));
+ FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(FX_DWORD));
} else {
for (int i = 0; i < palsize; i ++) {
FX_CMYK cmyk = pSrcPalette[i];
@@ -4236,7 +4236,7 @@
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_memset8(dest_scan, gray, width);
+ FXSYS_memset(dest_scan, gray, width);
} else
for (int col = 0; col < width; col ++) {
*dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
@@ -4264,7 +4264,7 @@
uint8_t left_flag = *dest_scan_top & (255 << (8 - left_shift));
uint8_t right_flag = *dest_scan_top_r & (255 >> right_shift);
if (width) {
- FXSYS_memset8(dest_scan_top + 1, index ? 255 : 0, width - 1);
+ FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, width - 1);
if (!index) {
*dest_scan_top &= left_flag;
*dest_scan_top_r &= right_flag;
@@ -4308,7 +4308,7 @@
uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
uint8_t* dest_scan_alpha = m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left : NULL;
if (dest_scan_alpha) {
- FXSYS_memset8(dest_scan_alpha, 0xff, width);
+ FXSYS_memset(dest_scan_alpha, 0xff, width);
}
if (Bpp == 4) {
FX_DWORD* scan = (FX_DWORD*)dest_scan;
@@ -4352,7 +4352,7 @@
uint8_t back_alpha = *dest_scan_alpha;
if (back_alpha == 0) {
*dest_scan_alpha++ = src_alpha;
- FXSYS_memcpy32(dest_scan, color_p, Bpp);
+ FXSYS_memcpy(dest_scan, color_p, Bpp);
dest_scan += Bpp;
continue;
}
@@ -4457,7 +4457,7 @@
m_pAddClipScan[i] = clip_scan[i] * m_BitmapAlpha / 255;
}
} else {
- FXSYS_memset8(m_pAddClipScan, m_BitmapAlpha, dest_width);
+ FXSYS_memset(m_pAddClipScan, m_BitmapAlpha, dest_width);
}
clip_scan = m_pAddClipScan;
}
diff --git a/core/src/fxge/dib/fx_dib_convert.cpp b/core/src/fxge/dib/fx_dib_convert.cpp
index c8de6ca..8e96379 100644
--- a/core/src/fxge/dib/fx_dib_convert.cpp
+++ b/core/src/fxge/dib/fx_dib_convert.cpp
@@ -287,7 +287,7 @@
reset_gray = 0x00;
for (int row = 0; row < height; row ++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
- FXSYS_memset8(dest_scan, reset_gray, width);
+ FXSYS_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))) {
@@ -304,7 +304,7 @@
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_memcpy32(dest_scan, src_scan, width);
+ FXSYS_memcpy(dest_scan, src_scan, width);
}
return TRUE;
}
@@ -350,7 +350,7 @@
}
for (int row = 0; row < height; row ++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
- FXSYS_memset8(dest_scan, gray[0], width);
+ FXSYS_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))) {
@@ -459,7 +459,7 @@
if (pSrcBitmap->GetBPP() == 1) {
for (int row = 0; row < height; row ++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
- FXSYS_memset32(dest_scan, 0, width);
+ FXSYS_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))) {
@@ -472,7 +472,7 @@
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_memcpy32(dest_scan, src_scan, width);
+ FXSYS_memcpy(dest_scan, src_scan, width);
}
}
}
@@ -512,7 +512,7 @@
dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
}
} else {
- FXSYS_memcpy32(dst_plt, src_plt, plt_size * 4);
+ FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
}
}
return TRUE;
@@ -570,7 +570,7 @@
}
}
}
- FXSYS_memcpy32(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
+ FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
return TRUE;
}
FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
@@ -738,7 +738,7 @@
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 * 3;
- FXSYS_memcpy32(dest_scan, src_scan, width * 3);
+ FXSYS_memcpy(dest_scan, src_scan, width * 3);
}
}
return TRUE;
@@ -1002,7 +1002,7 @@
}
CFX_DIBitmap* pAlphaMask = NULL;
if (dest_format == FXDIB_Argb) {
- FXSYS_memset8(dest_buf, 0xff, dest_pitch * m_Height + 4);
+ FXSYS_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/src/fxge/dib/fx_dib_engine.cpp b/core/src/fxge/dib/fx_dib_engine.cpp
index be39e35..7f6dc4e 100644
--- a/core/src/fxge/dib/fx_dib_engine.cpp
+++ b/core/src/fxge/dib/fx_dib_engine.cpp
@@ -207,7 +207,7 @@
return;
}
if (dest_format == FXDIB_Rgb32) {
- FXSYS_memset8(m_pDestScanline, 255, size);
+ FXSYS_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/src/fxge/dib/fx_dib_main.cpp b/core/src/fxge/dib/fx_dib_main.cpp
index ddbe554..aa7fe6c 100644
--- a/core/src/fxge/dib/fx_dib_main.cpp
+++ b/core/src/fxge/dib/fx_dib_main.cpp
@@ -120,7 +120,7 @@
CopyPalette(pSrc->GetPalette());
CopyAlphaMask(pSrc->m_pAlphaMask);
for (int row = 0; row < pSrc->GetHeight(); row ++) {
- FXSYS_memcpy32(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
}
return TRUE;
}
@@ -190,7 +190,7 @@
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_memcpy32(dest_scan, src_scan, copy_len);
+ FXSYS_memcpy(dest_scan, src_scan, copy_len);
}
}
return pNewBitmap;
@@ -233,7 +233,7 @@
m_pAlphaMask = NULL;
return FALSE;
}
- FXSYS_memset8(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
+ FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
return TRUE;
}
FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const
@@ -290,19 +290,19 @@
}
switch (GetFormat()) {
case FXDIB_1bppMask:
- FXSYS_memset8(m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
+ FXSYS_memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
break;
case FXDIB_1bppRgb: {
int index = FindPalette(color);
- FXSYS_memset8(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
+ FXSYS_memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
break;
}
case FXDIB_8bppMask:
- FXSYS_memset8(m_pBuffer, color >> 24, m_Pitch * m_Height);
+ FXSYS_memset(m_pBuffer, color >> 24, m_Pitch * m_Height);
break;
case FXDIB_8bppRgb: {
int index = FindPalette(color);
- FXSYS_memset8(m_pBuffer, index, m_Pitch * m_Height);
+ FXSYS_memset(m_pBuffer, index, m_Pitch * m_Height);
break;
}
case FXDIB_Rgb:
@@ -310,7 +310,7 @@
int a, r, g, b;
ArgbDecode(color, a, r, g, b);
if (r == g && g == b) {
- FXSYS_memset8(m_pBuffer, r, m_Pitch * m_Height);
+ FXSYS_memset(m_pBuffer, r, m_Pitch * m_Height);
} else {
int byte_pos = 0;
for (int col = 0; col < m_Width; col ++) {
@@ -319,7 +319,7 @@
m_pBuffer[byte_pos++] = r;
}
for (int row = 1; row < m_Height; row ++) {
- FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
}
}
break;
@@ -331,7 +331,7 @@
((FX_DWORD*)m_pBuffer)[i] = color;
}
for (int row = 1; row < m_Height; row ++) {
- FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
}
break;
}
@@ -401,7 +401,7 @@
for (int row = 0; row < height; row ++) {
uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
- FXSYS_memcpy32(dest_scan, src_scan, width * Bpp);
+ FXSYS_memcpy(dest_scan, src_scan, width * Bpp);
}
}
} else {
@@ -492,10 +492,10 @@
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_memcpy32(dest_color_pos, color_p, comps);
+ FXSYS_memcpy(dest_color_pos, color_p, comps);
*dest_alpha_pos = 0xff;
} else {
- FXSYS_memset32(dest_color_pos, 0, comps);
+ FXSYS_memset(dest_color_pos, 0, comps);
*dest_alpha_pos = 0;
}
dest_color_pos += comps;
@@ -504,7 +504,7 @@
} else {
src_scan += src_left;
for (int col = 0; col < width; col ++) {
- FXSYS_memcpy32(dest_color_pos, color_p, comps);
+ FXSYS_memcpy(dest_color_pos, color_p, comps);
dest_color_pos += comps;
*dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
}
@@ -528,7 +528,7 @@
if (pal_size > size) {
pal_size = size;
}
- FXSYS_memcpy32(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
+ FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
}
}
void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const
@@ -592,7 +592,7 @@
}
}
for (int row = 0; row < m_Height; row ++)
- FXSYS_memcpy32((void*)m_pAlphaMask->GetScanline(row),
+ FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),
pAlphaMask->GetScanline(row + rect.top) + rect.left, m_pAlphaMask->m_Pitch);
} else {
m_pAlphaMask->Clear(0xff000000);
@@ -783,11 +783,11 @@
}
int Bpp = GetBPP() / 8;
if (Bpp == 1) {
- FXSYS_memset8(m_pBuffer, value, m_Height * m_Pitch);
+ FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
return TRUE;
}
if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
- FXSYS_memset8(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
+ FXSYS_memset(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
return TRUE;
}
for (int row = 0; row < m_Height; row ++) {
@@ -889,7 +889,7 @@
delete pMask;
return FALSE;
}
- FXSYS_memset8(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
+ FXSYS_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);
@@ -1396,11 +1396,11 @@
const uint8_t* src_scan = GetScanline(row);
uint8_t* dest_scan = pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
if (!bXFlip) {
- FXSYS_memcpy32(dest_scan, src_scan, m_Pitch);
+ FXSYS_memcpy(dest_scan, src_scan, m_Pitch);
continue;
}
if (m_bpp == 1) {
- FXSYS_memset32(dest_scan, 0, m_Pitch);
+ FXSYS_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;
@@ -1439,7 +1439,7 @@
const uint8_t* src_scan = m_pAlphaMask->GetScanline(row);
uint8_t* dest_scan = pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row);
if (!bXFlip) {
- FXSYS_memcpy32(dest_scan, src_scan, dest_pitch);
+ FXSYS_memcpy(dest_scan, src_scan, dest_pitch);
continue;
}
dest_scan += (m_Width - 1);
@@ -1660,10 +1660,10 @@
uint8_t* dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
(uint8_t*)m_pBitmap->m_pAlphaMask->GetScanline(line) : NULL;
if (dest_buf) {
- FXSYS_memcpy32(dest_buf, scanline, m_pBitmap->GetPitch());
+ FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
}
if (dest_alpha_buf) {
- FXSYS_memcpy32(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
+ FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
}
}
FX_BOOL CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
diff --git a/core/src/fxge/dib/fx_dib_transform.cpp b/core/src/fxge/dib/fx_dib_transform.cpp
index 5a104c7..9c9c9ed 100644
--- a/core/src/fxge/dib/fx_dib_transform.cpp
+++ b/core/src/fxge/dib/fx_dib_transform.cpp
@@ -77,7 +77,7 @@
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_memset8(dest_buf, 0xff, dest_pitch * result_height);
+ FXSYS_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) - dest_clip.left;
diff --git a/core/src/fxge/ge/fx_ge_font.cpp b/core/src/fxge/ge/fx_ge_font.cpp
index 21c1081..c8d363b 100644
--- a/core/src/fxge/ge/fx_ge_font.cpp
+++ b/core/src/fxge/ge/fx_ge_font.cpp
@@ -174,7 +174,7 @@
FX_BOOL CFX_Font::LoadEmbedded(const uint8_t* data, FX_DWORD size)
{
m_pFontDataAllocation = FX_Alloc(uint8_t, size);
- FXSYS_memcpy32(m_pFontDataAllocation, data, size);
+ FXSYS_memcpy(m_pFontDataAllocation, data, size);
m_Face = FT_LoadFont((uint8_t*)m_pFontDataAllocation, size);
m_pFontData = (uint8_t*)m_pFontDataAllocation;
m_bEmbedded = TRUE;
diff --git a/core/src/fxge/ge/fx_ge_fontmap.cpp b/core/src/fxge/ge/fx_ge_fontmap.cpp
index ba5725d..bc37ac1 100644
--- a/core/src/fxge/ge/fx_ge_fontmap.cpp
+++ b/core/src/fxge/ge/fx_ge_fontmap.cpp
@@ -67,7 +67,7 @@
m_pBuiltinMapper->m_pFontMgr = this;
m_pExtMapper = NULL;
m_FTLibrary = NULL;
- FXSYS_memset32(m_ExternalFonts, 0, sizeof m_ExternalFonts);
+ FXSYS_memset(m_ExternalFonts, 0, sizeof m_ExternalFonts);
}
CFX_FontMgr::~CFX_FontMgr()
{
@@ -458,7 +458,7 @@
}
CFX_FontMapper::CFX_FontMapper()
{
- FXSYS_memset32(m_FoxitFaces, 0, sizeof m_FoxitFaces);
+ FXSYS_memset(m_FoxitFaces, 0, sizeof m_FoxitFaces);
m_MMFaces[0] = m_MMFaces[1] = NULL;
m_pFontInfo = NULL;
m_bListLoaded = FALSE;
diff --git a/core/src/fxge/ge/fx_ge_path.cpp b/core/src/fxge/ge/fx_ge_path.cpp
index 4ae7b42..fdc0dc8 100644
--- a/core/src/fxge/ge/fx_ge_path.cpp
+++ b/core/src/fxge/ge/fx_ge_path.cpp
@@ -139,7 +139,7 @@
if (m_AllocCount < nPoints) {
FX_PATHPOINT* pNewBuf = FX_Alloc(FX_PATHPOINT, nPoints);
if (m_PointCount) {
- FXSYS_memcpy32(pNewBuf, m_pPoints, m_PointCount * sizeof(FX_PATHPOINT));
+ FXSYS_memcpy(pNewBuf, m_pPoints, m_PointCount * sizeof(FX_PATHPOINT));
}
if (m_pPoints) {
FX_Free(m_pPoints);
@@ -152,7 +152,7 @@
{
m_PointCount = m_AllocCount = src.m_PointCount;
m_pPoints = FX_Alloc(FX_PATHPOINT, src.m_PointCount);
- FXSYS_memcpy32(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
+ FXSYS_memcpy(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
}
void CFX_PathData::TrimPoints(int nPoints)
{
@@ -173,7 +173,7 @@
{
int old_count = m_PointCount;
AddPointCount(pSrc->m_PointCount);
- FXSYS_memcpy32(m_pPoints + old_count, pSrc->m_pPoints, pSrc->m_PointCount * sizeof(FX_PATHPOINT));
+ FXSYS_memcpy(m_pPoints + old_count, pSrc->m_pPoints, pSrc->m_PointCount * sizeof(FX_PATHPOINT));
if (pMatrix) {
for (int i = 0; i < pSrc->m_PointCount; i ++) {
pMatrix->Transform(m_pPoints[old_count + i].m_PointX, m_pPoints[old_count + i].m_PointY);
@@ -575,7 +575,7 @@
void CFX_PathData::Copy(const CFX_PathData &src)
{
SetPointCount(src.m_PointCount);
- FXSYS_memcpy32(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
+ FXSYS_memcpy(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
}
CFX_GraphStateData::CFX_GraphStateData()
{
@@ -606,7 +606,7 @@
m_LineWidth = src.m_LineWidth;
if (m_DashCount) {
m_DashArray = FX_Alloc(FX_FLOAT, m_DashCount);
- FXSYS_memcpy32(m_DashArray, src.m_DashArray, m_DashCount * sizeof(FX_FLOAT));
+ FXSYS_memcpy(m_DashArray, src.m_DashArray, m_DashCount * sizeof(FX_FLOAT));
}
}
CFX_GraphStateData::~CFX_GraphStateData()
diff --git a/core/src/fxge/ge/fx_ge_ps.cpp b/core/src/fxge/ge/fx_ge_ps.cpp
index c8e56ad..734484d 100644
--- a/core/src/fxge/ge/fx_ge_ps.cpp
+++ b/core/src/fxge/ge/fx_ge_ps.cpp
@@ -242,7 +242,7 @@
buf << pGraphState->m_LineCap << FX_BSTRC(" J\n");
}
if (!m_bGraphStateSet || m_CurGraphState.m_DashCount != pGraphState->m_DashCount ||
- FXSYS_memcmp32(m_CurGraphState.m_DashArray, pGraphState->m_DashArray, sizeof(FX_FLOAT)*m_CurGraphState.m_DashCount)) {
+ FXSYS_memcmp(m_CurGraphState.m_DashArray, pGraphState->m_DashArray, sizeof(FX_FLOAT)*m_CurGraphState.m_DashCount)) {
buf << FX_BSTRC("[");
for (int i = 0; i < pGraphState->m_DashCount; i ++) {
buf << pGraphState->m_DashArray[i] << FX_BSTRC(" ");
@@ -351,7 +351,7 @@
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_memcpy32(src_buf + row * pitch, src_scan, pitch);
+ FXSYS_memcpy(src_buf + row * pitch, src_scan, pitch);
}
uint8_t* output_buf;
FX_DWORD output_size;
@@ -433,7 +433,7 @@
src_scan += 3;
}
} else {
- FXSYS_memcpy32(dest_scan, src_scan, src_pitch);
+ FXSYS_memcpy(dest_scan, src_scan, src_pitch);
}
}
uint8_t* compressed_buf;
diff --git a/core/src/fxge/ge/fx_ge_text.cpp b/core/src/fxge/ge/fx_ge_text.cpp
index 88eeb47..fd39ee8 100644
--- a/core/src/fxge/ge/fx_ge_text.cpp
+++ b/core/src/fxge/ge/fx_ge_text.cpp
@@ -1291,7 +1291,7 @@
if (0 == temp || 255 == temp) {
int rowbytes = FXSYS_abs(nSrcRowBytes) > nDstRowBytes ? nDstRowBytes : FXSYS_abs(nSrcRowBytes);
for (row = 0; row < nHei; row ++) {
- FXSYS_memcpy32(pDataOut + row * nDstRowBytes, pDataIn + row * nSrcRowBytes, rowbytes);
+ FXSYS_memcpy(pDataOut + row * nDstRowBytes, pDataIn + row * nSrcRowBytes, rowbytes);
}
return;
}
@@ -1408,11 +1408,11 @@
}
}
} else {
- FXSYS_memset32(pDestBuf, 0, dest_pitch * bmheight);
+ FXSYS_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 = FXSYS_abs(src_pitch) > dest_pitch ? dest_pitch : FXSYS_abs(src_pitch);
for (int row = 0; row < bmheight; row ++) {
- FXSYS_memcpy32(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, rowbytes);
+ FXSYS_memcpy(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, rowbytes);
}
} else {
_ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch, dest_pitch);
@@ -1447,7 +1447,7 @@
for (int row = 0; row < bmheight; row ++) {
const uint8_t* src_scan = src_buf + row * src_pitch;
uint8_t* dest_scan = dest_buf + row * dest_pitch;
- FXSYS_memcpy32(dest_scan, src_scan, dest_pitch);
+ FXSYS_memcpy(dest_scan, src_scan, dest_pitch);
}
pDib->CompositeMask(x + left, y - top, bmwidth, bmheight, &mask, argb, 0, 0);
return TRUE;
diff --git a/core/src/fxge/skia/fx_skia_blitter_new.cpp b/core/src/fxge/skia/fx_skia_blitter_new.cpp
index bcb50b9..e87092f 100644
--- a/core/src/fxge/skia/fx_skia_blitter_new.cpp
+++ b/core/src/fxge/skia/fx_skia_blitter_new.cpp
@@ -155,7 +155,7 @@
if (col_end < col_start) return; // do nothing.
dest_scan += col_start;
if (cover_scan == 255 && m_Alpha == 255) {
- FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
+ FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
return;
}
int src_alpha = m_Alpha * cover_scan / 255;
@@ -179,7 +179,7 @@
dest_scan += col_start;
ori_scan += col_start;
if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
+ FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
} else {
int src_alpha = m_Alpha;
#if 1
@@ -306,14 +306,14 @@
if (col_end < col_start) return; // do nothing.
dest_scan += col_start<<2;
if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
int src_alpha;
#if 0
if (m_bFullCover) {
if (m_Alpha == 255) {
- FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
}
@@ -358,12 +358,12 @@
//ori_scan += col_start << 2;
if (m_Alpha == 255 && cover_scan == 255){
- FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
if (cover_scan == 255) {
int dst_color = (0x00ffffff&m_Color)|(m_Alpha<<24);
- FXSYS_memset32(dest_scan, dst_color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, dst_color, (col_end - col_start)<<2);
return;
}
// Do not need origin bitmap, because of merge in pure transparent background
@@ -568,7 +568,7 @@
if (col_end < col_start) return; // do nothing.
dest_scan += (col_start << 2);
if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
int src_alpha;
@@ -601,7 +601,7 @@
dest_scan += col_start << 2;
ori_scan += col_start << 2;
if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
int src_alpha = m_Alpha;
@@ -1528,7 +1528,7 @@
if (result > 0) {
dest_pos = dest_scan + col_start;
if (result >= 4)
- FXSYS_memset32(dest_pos, FXARGB_MAKE(aa, aa, aa, aa),result);
+ FXSYS_memset(dest_pos, FXARGB_MAKE(aa, aa, aa, aa),result);
else
FXSYS_memset(dest_pos,aa,result);
}
@@ -1554,7 +1554,7 @@
if (result > 0) {
uint8_t* dest_pos = dest_scan + col_start;
if (result >= 4)
- FXSYS_memset32(dest_pos, 0xffffffff,result);
+ FXSYS_memset(dest_pos, 0xffffffff,result);
else
FXSYS_memset(dest_pos,255,result);
}
diff --git a/core/src/fxge/win32/fx_win32_device.cpp b/core/src/fxge/win32/fx_win32_device.cpp
index effff09..1c3c3d0 100644
--- a/core/src/fxge/win32/fx_win32_device.cpp
+++ b/core/src/fxge/win32/fx_win32_device.cpp
@@ -141,7 +141,7 @@
{
m_pMapper = pMapper;
LOGFONTA lf;
- FXSYS_memset32(&lf, 0, sizeof(LOGFONTA));
+ FXSYS_memset(&lf, 0, sizeof(LOGFONTA));
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfFaceName[0] = 0;
lf.lfPitchAndFamily = 0;
@@ -553,7 +553,7 @@
BITMAPINFOHEADER bmiHeader;
FX_DWORD bmiColors[2];
} bmi;
- FXSYS_memset32(&bmi.bmiHeader, 0, sizeof (BITMAPINFOHEADER));
+ FXSYS_memset(&bmi.bmiHeader, 0, sizeof (BITMAPINFOHEADER));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biBitCount = 1;
bmi.bmiHeader.biCompression = BI_RGB;
@@ -950,7 +950,7 @@
BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY);
SelectObject(hDCMemory, holdbmp);
BITMAPINFO bmi;
- FXSYS_memset32(&bmi, 0, sizeof bmi);
+ FXSYS_memset(&bmi, 0, sizeof bmi);
bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
bmi.bmiHeader.biBitCount = pBitmap->GetBPP();
bmi.bmiHeader.biHeight = -height;
@@ -1170,7 +1170,7 @@
CFX_WinBitmapDevice::CFX_WinBitmapDevice(int width, int height, FXDIB_Format format)
{
BITMAPINFOHEADER bmih;
- FXSYS_memset32(&bmih, 0, sizeof (BITMAPINFOHEADER));
+ FXSYS_memset(&bmih, 0, sizeof (BITMAPINFOHEADER));
bmih.biSize = sizeof(BITMAPINFOHEADER);
bmih.biBitCount = format & 0xff;
bmih.biHeight = -height;
diff --git a/core/src/fxge/win32/fx_win32_dib.cpp b/core/src/fxge/win32/fx_win32_dib.cpp
index a9b3662..4aa2a3a 100644
--- a/core/src/fxge/win32/fx_win32_dib.cpp
+++ b/core/src/fxge/win32/fx_win32_dib.cpp
@@ -17,7 +17,7 @@
len += sizeof (DWORD) * (int)(1 << pBitmap->GetBPP());
}
BITMAPINFOHEADER* pbmih = (BITMAPINFOHEADER*)result.GetBuffer(len);
- FXSYS_memset32(pbmih, 0, sizeof (BITMAPINFOHEADER));
+ FXSYS_memset(pbmih, 0, sizeof (BITMAPINFOHEADER));
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biBitCount = pBitmap->GetBPP();
pbmih->biCompression = BI_RGB;
@@ -66,14 +66,14 @@
delete pBitmap;
return NULL;
}
- FXSYS_memcpy32(pBitmap->GetBuffer(), pData, pitch * height);
+ FXSYS_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_memcpy32(temp_buf, pBitmap->GetBuffer() + top * pitch, pitch);
- FXSYS_memcpy32(pBitmap->GetBuffer() + top * pitch, pBitmap->GetBuffer() + bottom * pitch, pitch);
- FXSYS_memcpy32(pBitmap->GetBuffer() + bottom * pitch, temp_buf, pitch);
+ 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);
top ++;
bottom --;
}
@@ -182,7 +182,7 @@
hDC = CreateCompatibleDC(NULL);
}
BITMAPINFOHEADER bmih;
- FXSYS_memset32(&bmih, 0, sizeof bmih);
+ FXSYS_memset(&bmih, 0, sizeof bmih);
bmih.biSize = sizeof bmih;
GetDIBits(hDC, hBitmap, 0, 0, NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS);
int width = bmih.biWidth;
@@ -255,7 +255,7 @@
{
Create(width, height, FXDIB_Rgb, (uint8_t*)1);
BITMAPINFOHEADER bmih;
- FXSYS_memset32(&bmih, 0, sizeof bmih);
+ FXSYS_memset(&bmih, 0, sizeof bmih);
bmih.biSize = sizeof bmih;
bmih.biBitCount = 24;
bmih.biHeight = -height;
diff --git a/core/src/fxge/win32/fx_win32_gdipext.cpp b/core/src/fxge/win32/fx_win32_gdipext.cpp
index 863281b..3591c80 100644
--- a/core/src/fxge/win32/fx_win32_gdipext.cpp
+++ b/core/src/fxge/win32/fx_win32_gdipext.cpp
@@ -1043,7 +1043,7 @@
}
bytes_left = m_InterStream.GetLength() - m_ReadPos;
bytes_out = FX_MIN(cb, bytes_left);
- FXSYS_memcpy32(Output, m_InterStream.GetBuffer() + m_ReadPos, bytes_out);
+ FXSYS_memcpy(Output, m_InterStream.GetBuffer() + m_ReadPos, bytes_out);
m_ReadPos += (int32_t)bytes_out;
if (pcbRead != NULL) {
*pcbRead = (ULONG)bytes_out;
@@ -1240,10 +1240,10 @@
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_memcpy32(pData, pInfo->pScan0, dest_pitch * height);
+ FXSYS_memcpy(pData, pInfo->pScan0, dest_pitch * height);
} else {
for (int i = 0; i < height; i ++) {
- FXSYS_memcpy32(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i, dest_pitch);
+ FXSYS_memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i, dest_pitch);
}
}
CFX_DIBitmap* pDIBitmap = _FX_WindowsDIB_LoadFromBuf(pInfo->pbmi, pData, pInfo->pbmi->bmiHeader.biBitCount == 32);
diff --git a/core/src/fxge/win32/fx_win32_print.cpp b/core/src/fxge/win32/fx_win32_print.cpp
index e921d4c..eb3f823 100644
--- a/core/src/fxge/win32/fx_win32_print.cpp
+++ b/core/src/fxge/win32/fx_win32_print.cpp
@@ -154,7 +154,7 @@
pTempBitmap->CopyPalette(pSrc->GetPalette());
uint8_t* dest_buf = pTempBitmap->GetBuffer();
int dest_pitch = pTempBitmap->GetPitch();
- FXSYS_memset8(dest_buf, pSrc->IsAlphaMask() ? 0 : 0xff, dest_pitch * result_height);
+ FXSYS_memset(dest_buf, pSrc->IsAlphaMask() ? 0 : 0xff, dest_pitch * result_height);
if (pSrcBitmap->IsAlphaMask()) {
for (int dest_y = 0; dest_y < result_height; dest_y ++) {
uint8_t* dest_scan = dest_buf + dest_y * dest_pitch;
diff --git a/core/src/reflow/layoutprocessor_reflow.cpp b/core/src/reflow/layoutprocessor_reflow.cpp
index 7e9ff42..151ae9b 100644
--- a/core/src/reflow/layoutprocessor_reflow.cpp
+++ b/core/src/reflow/layoutprocessor_reflow.cpp
@@ -213,7 +213,7 @@
int rowCount = pTable->m_nCell.GetSize();
int n = 0;
FX_FLOAT* dyRow = FX_Alloc(FX_FLOAT, rowCount + 1);
- FXSYS_memset32(dyRow, 0, sizeof(FX_FLOAT) * (rowCount + 1));
+ FXSYS_memset(dyRow, 0, sizeof(FX_FLOAT) * (rowCount + 1));
dyRow[0] = 0 ;
dyRow[0] = - pTable->m_ReflowPageHeight;
int tableColCount = 0;
@@ -226,7 +226,7 @@
}
int cellCount = tableColCount * rowCount;
RF_TableCell** pVirtualTable = FX_Alloc(RF_TableCell*, cellCount);
- FXSYS_memset32(pVirtualTable, 0, sizeof(RF_TableCell*) * cellCount);
+ FXSYS_memset(pVirtualTable, 0, sizeof(RF_TableCell*) * cellCount);
for(i = 0; i < rowCount; i++) {
int colCount = pTable->m_nCell.GetAt(i);
FX_FLOAT rowWidth = 0;
@@ -583,7 +583,7 @@
break;
}
RF_TableCell* pCell = FX_Alloc(RF_TableCell, 1);
- FXSYS_memset32(pCell, 0 , sizeof(RF_TableCell));
+ FXSYS_memset(pCell, 0 , sizeof(RF_TableCell));
CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
int pos = pTable->m_nCell.GetSize() - 1;
pCell->m_BeginPos = m_pReflowedPage->m_pReflowed->GetSize();
