Convert all line endings to LF.

1 files changed, 232 insertions, 232 deletions

diff --git a/core/src/fxcrt/mem_int.h b/core/src/fxcrt/mem_int.h
index da43023bb5..3e3d25a7ec 100644
--- a/core/src/fxcrt/mem_int.h
+++ b/core/src/fxcrt/mem_int.h
@@ -1,232 +1,232 @@
-// Copyright 2014 PDFium Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

- 

-// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

-

-#ifndef _FXM_MEM_INT_H_

-#define _FXM_MEM_INT_H_

-struct FX_DefAllocator {

-    IFX_Allocator			m_Allocator;

-    struct CFX_MemoryMgr*	m_pFoxitMgr;

-};

-struct CFX_MemoryMgr {

-public:

-    FXMEM_SystemMgr*	m_pSystemMgr;

-    FX_DefAllocator		m_DefAllocator;

-    FX_LPVOID			m_pExternalMemory;

-    FX_BOOL				m_bReleaseMgr;

-    void			Init(FXMEM_SystemMgr* pSystemMgr);

-    void*			Alloc(size_t size, int flags);

-    void*			AllocDebug(size_t size, int flags, FX_LPCSTR file, int line);

-    void*			Realloc(void* p, size_t size, int flags);

-    void*			ReallocDebug(void* p, size_t size, int flags, FX_LPCSTR file, int line);

-    void			Free(void* p, int flags);

-    void			PurgeMgr();

-};

-extern CFX_MemoryMgr* g_pDefFoxitMgr;

-#define FIXEDMEM_PAGE_EXTRASPACE		sizeof(size_t)

-#define FIXEDMEM_BLOCKNUM(bs)			(8 * (FX_FIXEDMEM_PAGESIZE - FIXEDMEM_PAGE_EXTRASPACE) / (8 * bs + 1))

-#define FIXEDMEM_8BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(8)

-#define FIXEDMEM_16BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(16)

-#define FIXEDMEM_32BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(32)

-extern const FX_BYTE ZeroLeadPos[256];

-extern const FX_BYTE OneLeadPos[256];

-template <size_t blockNum, size_t blockSize>

-class CFXMEM_FixedPage

-{

-public:

-    void		Initialize()

-    {

-        m_nAvailCount = blockNum;

-        FXSYS_memset32(m_BusyMap, 0, (blockNum + 7) / 8);

-    }

-    FX_BOOL		HasFreeBlock() const

-    {

-        return (FX_BOOL)m_nAvailCount;

-    }

-    FX_LPVOID	Alloc(size_t size)

-    {

-        FXSYS_assert(m_nAvailCount);

-        FX_LPDWORD pFind = (FX_LPDWORD)m_BusyMap;

-        size_t i = 0;

-        while (i < (blockNum + 7) / 8 / 4 && pFind[i] == 0xFFFFFFFF) {

-            i ++;

-        }

-        i *= 4;

-        while (m_BusyMap[i] == 0xFF) {

-            i ++;

-        }

-        size_t pos = ZeroLeadPos[m_BusyMap[i]];

-        m_BusyMap[i] |= 1 << (7 - pos);

-        m_nAvailCount --;

-        return (FX_LPBYTE)(this + 1) + (i * 8 + pos) * blockSize;

-    }

-    void		Free(FX_LPVOID p)

-    {

-        FXSYS_assert(p > (FX_LPVOID)this && p < (FX_LPVOID)((FX_LPBYTE)this + FX_FIXEDMEM_PAGESIZE));

-        size_t pos = ((FX_LPBYTE)p - (FX_LPBYTE)(this + 1)) / blockSize;

-        m_BusyMap[pos / 8] &= ~(1 << (7 - (pos % 8)));

-        m_nAvailCount ++;

-    }

-    volatile size_t	m_nAvailCount;

-    FX_BYTE			m_BusyMap[(blockNum + 7) / 8];

-};

-typedef CFXMEM_FixedPage<FIXEDMEM_8BYTES_BLOCKNUM, 8>	CFXMEM_8BytesPage;

-typedef CFXMEM_FixedPage<FIXEDMEM_16BYTES_BLOCKNUM, 16>	CFXMEM_16BytesPage;

-typedef CFXMEM_FixedPage<FIXEDMEM_32BYTES_BLOCKNUM, 32>	CFXMEM_32BytesPage;

-template <size_t blockNum, size_t blockSize>

-class CFXMEM_FixedPages

-{

-public:

-    typedef CFXMEM_FixedPage<blockNum, blockSize> T;

-    FX_LPBYTE		m_pStartPage;

-    FX_LPBYTE		m_pLimitPos;

-    FX_LPBYTE		m_pCurPage;

-    volatile size_t	m_nAvailBlocks;

-    void		Initialize(FX_LPBYTE pStart, size_t pages)

-    {

-        m_pStartPage = m_pCurPage = pStart;

-        m_nAvailBlocks = pages * blockNum;

-        for (size_t n = 0; n < pages; n ++) {

-            ((T*)pStart)->Initialize();

-            pStart += FX_FIXEDMEM_PAGESIZE;

-        }

-        m_pLimitPos = pStart;

-    }

-    FX_BOOL		IsEmpty() const

-    {

-        return m_nAvailBlocks == (m_pLimitPos - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * blockNum;

-    }

-    FX_BOOL		HasFreeBlock() const

-    {

-        return (FX_BOOL)m_nAvailBlocks;

-    }

-    FX_LPVOID	Alloc(size_t size)

-    {

-        FXSYS_assert(m_nAvailBlocks);

-        do {

-            if (((T*)m_pCurPage)->HasFreeBlock()) {

-                m_nAvailBlocks --;

-                return ((T*)m_pCurPage)->Alloc(size);

-            }

-            m_pCurPage += FX_FIXEDMEM_PAGESIZE;

-            if (m_pCurPage == m_pLimitPos) {

-                m_pCurPage = m_pStartPage;

-            }

-        } while (TRUE);

-        return NULL;

-    }

-    void		Free(FX_LPVOID p)

-    {

-        FXSYS_assert(p > (FX_LPVOID)m_pStartPage && p < (FX_LPVOID)m_pLimitPos);

-        ((T*)(m_pStartPage + ((FX_LPBYTE)p - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * FX_FIXEDMEM_PAGESIZE))->Free(p);

-        m_nAvailBlocks ++;

-    }

-};

-typedef CFXMEM_FixedPages<FIXEDMEM_8BYTES_BLOCKNUM, 8>		CFXMEM_8BytesPages;

-typedef CFXMEM_FixedPages<FIXEDMEM_16BYTES_BLOCKNUM, 16>	CFXMEM_16BytesPages;

-typedef CFXMEM_FixedPages<FIXEDMEM_32BYTES_BLOCKNUM, 32>	CFXMEM_32BytesPages;

-class CFXMEM_Block

-{

-public:

-    size_t			m_nBlockSize;

-    CFXMEM_Block*	m_pNextBlock;

-};

-class CFXMEM_Page

-{

-public:

-    size_t			m_nAvailSize;

-    CFXMEM_Block*	m_pLimitPos;

-    CFXMEM_Block	m_AvailHead;

-    void		Initialize(size_t size);

-    FX_BOOL		IsEmpty() const

-    {

-        return m_AvailHead.m_pNextBlock && m_AvailHead.m_nBlockSize == m_AvailHead.m_pNextBlock->m_nBlockSize;

-    }

-    FX_LPVOID	Alloc(size_t size);

-    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);

-    void		Free(FX_LPVOID p);

-protected:

-    FX_LPVOID	Alloc(CFXMEM_Block* pPrevBlock, CFXMEM_Block* pNextBlock, size_t size, size_t oldsize);

-};

-class CFXMEM_Pages

-{

-public:

-    CFXMEM_Page*	m_pStartPage;

-    CFXMEM_Page*	m_pLimitPos;

-    CFXMEM_Page*	m_pCurPage;

-    size_t			m_nPageSize;

-    void		Initialize(FX_LPBYTE pStart, size_t pageSize, size_t pages);

-    FX_BOOL		IsEmpty() const;

-    FX_LPVOID	Alloc(size_t size);

-    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);

-    void		Free(FX_LPVOID p);

-};

-class CFXMEM_Pool

-{

-public:

-    CFXMEM_Pool*			m_pPrevPool;

-    CFXMEM_Pool*			m_pNextPool;

-    CFXMEM_8BytesPages		m_8BytesPages;

-    CFXMEM_16BytesPages		m_16BytesPages;

-    CFXMEM_32BytesPages		m_32BytesPages;

-    CFXMEM_Pages			m_MidPages;

-    FX_BOOL					m_bAlone;

-    FX_DWORD				m_dwReserved[3];

-    FX_LPVOID				m_pLimitPos;

-    CFXMEM_Page*			m_pLargePage;

-    void		Initialize(const FX_MEMCONFIG* pMemConfig, size_t size, size_t pageNum8Bytes, size_t pageNum16Bytes, size_t pageNum32Bytes, size_t pageNumMid);

-    FX_BOOL		IsEmpty() const;

-    size_t		GetSize(FX_LPVOID p) const;

-    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);

-    void		Free(FX_LPVOID p);

-};

-class CFXMEM_FixedMgr

-{

-public:

-    void			Initialize(size_t size);

-    FX_LPVOID		Alloc(size_t size);

-    FX_LPVOID		Realloc(FX_LPVOID p, size_t newSize);

-    void			Free(FX_LPVOID p);

-    void			FreeAll();

-    void			Purge();

-    CFXMEM_Pool*	GetFirstPool()

-    {

-        return &m_FirstPool;

-    }

-    size_t			GetSize(FX_LPVOID p) const;

-    FXMEM_SystemMgr		m_SystemMgr;

-    FXMEM_SystemMgr2*	m_pExtender;

-    FX_LPVOID			m_pReserved;

-    FX_MEMCONFIG		m_MemConfig;

-protected:

-    FX_LPVOID		Alloc16(CFXMEM_Pool **pp32Pool = NULL, size_t size = 0);

-    FX_LPVOID		Alloc32(size_t size);

-    FX_LPVOID		AllocSmall(size_t size);

-    FX_LPVOID		AllocMid(size_t size);

-    FX_LPVOID		AllocLarge(size_t size);

-    FX_LPVOID		ReallocSmall(CFXMEM_Pool* pPool, FX_LPVOID p, size_t oldSize, size_t newSize);

-    void			FreePool(CFXMEM_Pool* pPool);

-    CFXMEM_Pool		m_FirstPool;

-};

-#define FIXEDMEM_PROXYSIZE_0	(1024 * 1024 * 8)

-#define FIXEDMEM_PROXYSIZE_1	(1024 * 1024 * 16)

-#define FIXEDMEM_PROXYSIZE_2	(1024 * 1024 * 32)

-#define FIXEDMEM_PROXYSIZE_3	(1024 * 1024 * 64)

-#define FIXEDMEM_PROXYSIZE_4	(1024 * 1024 * 128)

-#define FIXEDMEM_PROXYSIZE_5	(1024 * 1024 * 256)

-const FX_MEMCONFIG*	FixedMgr_GetConfig(size_t nSize);

-class CFixedMgr_Proxy

-{

-public:

-    FXMEM_FoxitMgr*	Initialize(FX_LPVOID pBuffer, size_t nSize, FX_BOOL bExtensible);

-    static FX_BOOL	Common_More(FXMEM_SystemMgr2* pMgr, size_t alloc_size, void** new_memory, size_t* new_size);

-    static void		Common_Free(FXMEM_SystemMgr2* pMgr, void* memory);

-    FXMEM_SystemMgr2	m_SystemMgr;

-    CFXMEM_Page*		m_pFixedPage;

-    FX_LPVOID			m_pBuffer;

-    size_t				m_nSize;

-    FX_BOOL				m_bExtensible;

-};

-#endif

+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#ifndef _FXM_MEM_INT_H_
+#define _FXM_MEM_INT_H_
+struct FX_DefAllocator {
+    IFX_Allocator			m_Allocator;
+    struct CFX_MemoryMgr*	m_pFoxitMgr;
+};
+struct CFX_MemoryMgr {
+public:
+    FXMEM_SystemMgr*	m_pSystemMgr;
+    FX_DefAllocator		m_DefAllocator;
+    FX_LPVOID			m_pExternalMemory;
+    FX_BOOL				m_bReleaseMgr;
+    void			Init(FXMEM_SystemMgr* pSystemMgr);
+    void*			Alloc(size_t size, int flags);
+    void*			AllocDebug(size_t size, int flags, FX_LPCSTR file, int line);
+    void*			Realloc(void* p, size_t size, int flags);
+    void*			ReallocDebug(void* p, size_t size, int flags, FX_LPCSTR file, int line);
+    void			Free(void* p, int flags);
+    void			PurgeMgr();
+};
+extern CFX_MemoryMgr* g_pDefFoxitMgr;
+#define FIXEDMEM_PAGE_EXTRASPACE		sizeof(size_t)
+#define FIXEDMEM_BLOCKNUM(bs)			(8 * (FX_FIXEDMEM_PAGESIZE - FIXEDMEM_PAGE_EXTRASPACE) / (8 * bs + 1))
+#define FIXEDMEM_8BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(8)
+#define FIXEDMEM_16BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(16)
+#define FIXEDMEM_32BYTES_BLOCKNUM		FIXEDMEM_BLOCKNUM(32)
+extern const FX_BYTE ZeroLeadPos[256];
+extern const FX_BYTE OneLeadPos[256];
+template <size_t blockNum, size_t blockSize>
+class CFXMEM_FixedPage
+{
+public:
+    void		Initialize()
+    {
+        m_nAvailCount = blockNum;
+        FXSYS_memset32(m_BusyMap, 0, (blockNum + 7) / 8);
+    }
+    FX_BOOL		HasFreeBlock() const
+    {
+        return (FX_BOOL)m_nAvailCount;
+    }
+    FX_LPVOID	Alloc(size_t size)
+    {
+        FXSYS_assert(m_nAvailCount);
+        FX_LPDWORD pFind = (FX_LPDWORD)m_BusyMap;
+        size_t i = 0;
+        while (i < (blockNum + 7) / 8 / 4 && pFind[i] == 0xFFFFFFFF) {
+            i ++;
+        }
+        i *= 4;
+        while (m_BusyMap[i] == 0xFF) {
+            i ++;
+        }
+        size_t pos = ZeroLeadPos[m_BusyMap[i]];
+        m_BusyMap[i] |= 1 << (7 - pos);
+        m_nAvailCount --;
+        return (FX_LPBYTE)(this + 1) + (i * 8 + pos) * blockSize;
+    }
+    void		Free(FX_LPVOID p)
+    {
+        FXSYS_assert(p > (FX_LPVOID)this && p < (FX_LPVOID)((FX_LPBYTE)this + FX_FIXEDMEM_PAGESIZE));
+        size_t pos = ((FX_LPBYTE)p - (FX_LPBYTE)(this + 1)) / blockSize;
+        m_BusyMap[pos / 8] &= ~(1 << (7 - (pos % 8)));
+        m_nAvailCount ++;
+    }
+    volatile size_t	m_nAvailCount;
+    FX_BYTE			m_BusyMap[(blockNum + 7) / 8];
+};
+typedef CFXMEM_FixedPage<FIXEDMEM_8BYTES_BLOCKNUM, 8>	CFXMEM_8BytesPage;
+typedef CFXMEM_FixedPage<FIXEDMEM_16BYTES_BLOCKNUM, 16>	CFXMEM_16BytesPage;
+typedef CFXMEM_FixedPage<FIXEDMEM_32BYTES_BLOCKNUM, 32>	CFXMEM_32BytesPage;
+template <size_t blockNum, size_t blockSize>
+class CFXMEM_FixedPages
+{
+public:
+    typedef CFXMEM_FixedPage<blockNum, blockSize> T;
+    FX_LPBYTE		m_pStartPage;
+    FX_LPBYTE		m_pLimitPos;
+    FX_LPBYTE		m_pCurPage;
+    volatile size_t	m_nAvailBlocks;
+    void		Initialize(FX_LPBYTE pStart, size_t pages)
+    {
+        m_pStartPage = m_pCurPage = pStart;
+        m_nAvailBlocks = pages * blockNum;
+        for (size_t n = 0; n < pages; n ++) {
+            ((T*)pStart)->Initialize();
+            pStart += FX_FIXEDMEM_PAGESIZE;
+        }
+        m_pLimitPos = pStart;
+    }
+    FX_BOOL		IsEmpty() const
+    {
+        return m_nAvailBlocks == (m_pLimitPos - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * blockNum;
+    }
+    FX_BOOL		HasFreeBlock() const
+    {
+        return (FX_BOOL)m_nAvailBlocks;
+    }
+    FX_LPVOID	Alloc(size_t size)
+    {
+        FXSYS_assert(m_nAvailBlocks);
+        do {
+            if (((T*)m_pCurPage)->HasFreeBlock()) {
+                m_nAvailBlocks --;
+                return ((T*)m_pCurPage)->Alloc(size);
+            }
+            m_pCurPage += FX_FIXEDMEM_PAGESIZE;
+            if (m_pCurPage == m_pLimitPos) {
+                m_pCurPage = m_pStartPage;
+            }
+        } while (TRUE);
+        return NULL;
+    }
+    void		Free(FX_LPVOID p)
+    {
+        FXSYS_assert(p > (FX_LPVOID)m_pStartPage && p < (FX_LPVOID)m_pLimitPos);
+        ((T*)(m_pStartPage + ((FX_LPBYTE)p - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * FX_FIXEDMEM_PAGESIZE))->Free(p);
+        m_nAvailBlocks ++;
+    }
+};
+typedef CFXMEM_FixedPages<FIXEDMEM_8BYTES_BLOCKNUM, 8>		CFXMEM_8BytesPages;
+typedef CFXMEM_FixedPages<FIXEDMEM_16BYTES_BLOCKNUM, 16>	CFXMEM_16BytesPages;
+typedef CFXMEM_FixedPages<FIXEDMEM_32BYTES_BLOCKNUM, 32>	CFXMEM_32BytesPages;
+class CFXMEM_Block
+{
+public:
+    size_t			m_nBlockSize;
+    CFXMEM_Block*	m_pNextBlock;
+};
+class CFXMEM_Page
+{
+public:
+    size_t			m_nAvailSize;
+    CFXMEM_Block*	m_pLimitPos;
+    CFXMEM_Block	m_AvailHead;
+    void		Initialize(size_t size);
+    FX_BOOL		IsEmpty() const
+    {
+        return m_AvailHead.m_pNextBlock && m_AvailHead.m_nBlockSize == m_AvailHead.m_pNextBlock->m_nBlockSize;
+    }
+    FX_LPVOID	Alloc(size_t size);
+    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
+    void		Free(FX_LPVOID p);
+protected:
+    FX_LPVOID	Alloc(CFXMEM_Block* pPrevBlock, CFXMEM_Block* pNextBlock, size_t size, size_t oldsize);
+};
+class CFXMEM_Pages
+{
+public:
+    CFXMEM_Page*	m_pStartPage;
+    CFXMEM_Page*	m_pLimitPos;
+    CFXMEM_Page*	m_pCurPage;
+    size_t			m_nPageSize;
+    void		Initialize(FX_LPBYTE pStart, size_t pageSize, size_t pages);
+    FX_BOOL		IsEmpty() const;
+    FX_LPVOID	Alloc(size_t size);
+    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
+    void		Free(FX_LPVOID p);
+};
+class CFXMEM_Pool
+{
+public:
+    CFXMEM_Pool*			m_pPrevPool;
+    CFXMEM_Pool*			m_pNextPool;
+    CFXMEM_8BytesPages		m_8BytesPages;
+    CFXMEM_16BytesPages		m_16BytesPages;
+    CFXMEM_32BytesPages		m_32BytesPages;
+    CFXMEM_Pages			m_MidPages;
+    FX_BOOL					m_bAlone;
+    FX_DWORD				m_dwReserved[3];
+    FX_LPVOID				m_pLimitPos;
+    CFXMEM_Page*			m_pLargePage;
+    void		Initialize(const FX_MEMCONFIG* pMemConfig, size_t size, size_t pageNum8Bytes, size_t pageNum16Bytes, size_t pageNum32Bytes, size_t pageNumMid);
+    FX_BOOL		IsEmpty() const;
+    size_t		GetSize(FX_LPVOID p) const;
+    FX_LPVOID	Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
+    void		Free(FX_LPVOID p);
+};
+class CFXMEM_FixedMgr
+{
+public:
+    void			Initialize(size_t size);
+    FX_LPVOID		Alloc(size_t size);
+    FX_LPVOID		Realloc(FX_LPVOID p, size_t newSize);
+    void			Free(FX_LPVOID p);
+    void			FreeAll();
+    void			Purge();
+    CFXMEM_Pool*	GetFirstPool()
+    {
+        return &m_FirstPool;
+    }
+    size_t			GetSize(FX_LPVOID p) const;
+    FXMEM_SystemMgr		m_SystemMgr;
+    FXMEM_SystemMgr2*	m_pExtender;
+    FX_LPVOID			m_pReserved;
+    FX_MEMCONFIG		m_MemConfig;
+protected:
+    FX_LPVOID		Alloc16(CFXMEM_Pool **pp32Pool = NULL, size_t size = 0);
+    FX_LPVOID		Alloc32(size_t size);
+    FX_LPVOID		AllocSmall(size_t size);
+    FX_LPVOID		AllocMid(size_t size);
+    FX_LPVOID		AllocLarge(size_t size);
+    FX_LPVOID		ReallocSmall(CFXMEM_Pool* pPool, FX_LPVOID p, size_t oldSize, size_t newSize);
+    void			FreePool(CFXMEM_Pool* pPool);
+    CFXMEM_Pool		m_FirstPool;
+};
+#define FIXEDMEM_PROXYSIZE_0	(1024 * 1024 * 8)
+#define FIXEDMEM_PROXYSIZE_1	(1024 * 1024 * 16)
+#define FIXEDMEM_PROXYSIZE_2	(1024 * 1024 * 32)
+#define FIXEDMEM_PROXYSIZE_3	(1024 * 1024 * 64)
+#define FIXEDMEM_PROXYSIZE_4	(1024 * 1024 * 128)
+#define FIXEDMEM_PROXYSIZE_5	(1024 * 1024 * 256)
+const FX_MEMCONFIG*	FixedMgr_GetConfig(size_t nSize);
+class CFixedMgr_Proxy
+{
+public:
+    FXMEM_FoxitMgr*	Initialize(FX_LPVOID pBuffer, size_t nSize, FX_BOOL bExtensible);
+    static FX_BOOL	Common_More(FXMEM_SystemMgr2* pMgr, size_t alloc_size, void** new_memory, size_t* new_size);
+    static void		Common_Free(FXMEM_SystemMgr2* pMgr, void* memory);
+    FXMEM_SystemMgr2	m_SystemMgr;
+    CFXMEM_Page*		m_pFixedPage;
+    FX_LPVOID			m_pBuffer;
+    size_t				m_nSize;
+    FX_BOOL				m_bExtensible;
+};
+#endif