Index: core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftutil.c |
diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftutil.c b/core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftutil.c |
deleted file mode 100644 |
index 4c0b916fe10a1e969986599ddfb2087859cafa01..0000000000000000000000000000000000000000 |
--- a/core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftutil.c |
+++ /dev/null |
@@ -1,548 +0,0 @@ |
-/***************************************************************************/ |
-/* */ |
-/* ftutil.c */ |
-/* */ |
-/* FreeType utility file for memory and list management (body). */ |
-/* */ |
-/* Copyright 2002, 2004-2007, 2013 by */ |
-/* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
-/* */ |
-/* This file is part of the FreeType project, and may only be used, */ |
-/* modified, and distributed under the terms of the FreeType project */ |
-/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
-/* this file you indicate that you have read the license and */ |
-/* understand and accept it fully. */ |
-/* */ |
-/***************************************************************************/ |
- |
- |
-#include "../../include/ft2build.h" |
-#include "../../include/freetype/internal/ftdebug.h" |
-#include "../../include/freetype/internal/ftmemory.h" |
-#include "../../include/freetype/internal/ftobjs.h" |
-#include "../../include/freetype/ftlist.h" |
- |
- |
- /*************************************************************************/ |
- /* */ |
- /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ |
- /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ |
- /* messages during execution. */ |
- /* */ |
-#undef FT_COMPONENT |
-#define FT_COMPONENT trace_memory |
- |
- |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /***** *****/ |
- /***** *****/ |
- /***** M E M O R Y M A N A G E M E N T *****/ |
- /***** *****/ |
- /***** *****/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_alloc( FT_Memory memory, |
- FT_Long size, |
- FT_Error *p_error ) |
- { |
- FT_Error error; |
- FT_Pointer block = ft_mem_qalloc( memory, size, &error ); |
- |
- if ( !error && size > 0 ) |
- FT_MEM_ZERO( block, size ); |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_qalloc( FT_Memory memory, |
- FT_Long size, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- FT_Pointer block = NULL; |
- |
- |
- if ( size > 0 ) |
- { |
- block = memory->alloc( memory, size ); |
- if ( block == NULL ) |
- error = FT_THROW( Out_Of_Memory ); |
- } |
- else if ( size < 0 ) |
- { |
- /* may help catch/prevent security issues */ |
- error = FT_THROW( Invalid_Argument ); |
- } |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_realloc( FT_Memory memory, |
- FT_Long item_size, |
- FT_Long cur_count, |
- FT_Long new_count, |
- void* block, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- |
- |
- block = ft_mem_qrealloc( memory, item_size, |
- cur_count, new_count, block, &error ); |
- if ( !error && new_count > cur_count ) |
- FT_MEM_ZERO( (char*)block + cur_count * item_size, |
- ( new_count - cur_count ) * item_size ); |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_qrealloc( FT_Memory memory, |
- FT_Long item_size, |
- FT_Long cur_count, |
- FT_Long new_count, |
- void* block, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- |
- |
- /* Note that we now accept `item_size == 0' as a valid parameter, in |
- * order to cover very weird cases where an ALLOC_MULT macro would be |
- * called. |
- */ |
- if ( cur_count < 0 || new_count < 0 || item_size < 0 ) |
- { |
- /* may help catch/prevent nasty security issues */ |
- error = FT_THROW( Invalid_Argument ); |
- } |
- else if ( new_count == 0 || item_size == 0 ) |
- { |
- ft_mem_free( memory, block ); |
- block = NULL; |
- } |
- else if ( new_count > FT_INT_MAX/item_size ) |
- { |
- error = FT_THROW( Array_Too_Large ); |
- } |
- else if ( cur_count == 0 ) |
- { |
- FT_ASSERT( block == NULL ); |
- |
- block = ft_mem_alloc( memory, new_count*item_size, &error ); |
- } |
- else |
- { |
- FT_Pointer block2; |
- FT_Long cur_size = cur_count*item_size; |
- FT_Long new_size = new_count*item_size; |
- |
- |
- block2 = memory->realloc( memory, cur_size, new_size, block ); |
- if ( block2 == NULL ) |
- error = FT_THROW( Out_Of_Memory ); |
- else |
- block = block2; |
- } |
- |
- *p_error = error; |
- return block; |
- } |
- |
- #ifdef _XYQ_MEM_DEBUG /** XYQ 2006-10-12 */ |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_allocdebug( FT_Memory memory, |
- FT_Long size, const char* file, int line, |
- FT_Error *p_error ) |
- { |
- FT_Error error; |
- FT_Pointer block = ft_mem_qallocdebug( memory, size, file, line, &error ); |
- |
- if ( !error && size > 0 ) |
- FT_MEM_ZERO( block, size ); |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_qallocdebug( FT_Memory memory, |
- FT_Long size, const char* file, int line, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- FT_Pointer block = NULL; |
- |
- |
- if ( size > 0 ) |
- { |
- block = memory->allocdebug( memory, size, file, line ); |
- if ( block == NULL ) |
- error = FT_Err_Out_Of_Memory; |
- } |
- else if ( size < 0 ) |
- { |
- /* may help catch/prevent security issues */ |
- error = FT_Err_Invalid_Argument; |
- } |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_reallocdebug( FT_Memory memory, |
- FT_Long item_size, |
- FT_Long cur_count, |
- FT_Long new_count, |
- void* block, const char* file, int line, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- |
- block = ft_mem_qreallocdebug( memory, item_size, |
- cur_count, new_count, block, file, line, &error ); |
- if ( !error && new_count > cur_count ) |
- FT_MEM_ZERO( (char*)block + cur_count * item_size, |
- ( new_count - cur_count ) * item_size ); |
- |
- *p_error = error; |
- return block; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_qreallocdebug( FT_Memory memory, |
- FT_Long item_size, |
- FT_Long cur_count, |
- FT_Long new_count, |
- void* block, const char* file, int line, |
- FT_Error *p_error ) |
- { |
- FT_Error error = FT_Err_Ok; |
- |
- |
- if ( cur_count < 0 || new_count < 0 || item_size <= 0 ) |
- { |
- /* may help catch/prevent nasty security issues */ |
- error = FT_Err_Invalid_Argument; |
- } |
- else if ( new_count == 0 ) |
- { |
- ft_mem_free( memory, block ); |
- block = NULL; |
- } |
- else if ( new_count > FT_INT_MAX/item_size ) |
- { |
- error = FT_Err_Array_Too_Large; |
- } |
- else if ( cur_count == 0 ) |
- { |
- FT_ASSERT( block == NULL ); |
- |
- block = ft_mem_allocdebug( memory, new_count*item_size, file, line, &error ); |
- } |
- else |
- { |
- FT_Pointer block2; |
- FT_Long cur_size = cur_count*item_size; |
- FT_Long new_size = new_count*item_size; |
- |
- |
- block2 = memory->realloc( memory, cur_size, new_size, block ); |
- if ( block2 == NULL ) |
- error = FT_Err_Out_Of_Memory; |
- else |
- block = block2; |
- } |
- |
- *p_error = error; |
- return block; |
- } |
-#endif |
- FT_BASE_DEF( void ) |
- ft_mem_free( FT_Memory memory, |
- const void *P ) |
- { |
- if ( P ) |
- memory->free( memory, (void*)P ); |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_dup( FT_Memory memory, |
- const void* address, |
- FT_ULong size, |
- FT_Error *p_error ) |
- { |
- FT_Error error; |
- FT_Pointer p = ft_mem_qalloc( memory, size, &error ); |
- |
- |
- if ( !error && address ) |
- ft_memcpy( p, address, size ); |
- |
- *p_error = error; |
- return p; |
- } |
- |
- |
- FT_BASE_DEF( FT_Pointer ) |
- ft_mem_strdup( FT_Memory memory, |
- const char* str, |
- FT_Error *p_error ) |
- { |
- FT_ULong len = str ? (FT_ULong)ft_strlen( str ) + 1 |
- : 0; |
- |
- |
- return ft_mem_dup( memory, str, len, p_error ); |
- } |
- |
- |
- FT_BASE_DEF( FT_Int ) |
- ft_mem_strcpyn( char* dst, |
- const char* src, |
- FT_ULong size ) |
- { |
- while ( size > 1 && *src != 0 ) |
- { |
- *dst++ = *src++; |
- size--; |
- } |
- |
- *dst = 0; /* always zero-terminate */ |
- |
- return *src != 0; |
- } |
- |
- |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /***** *****/ |
- /***** *****/ |
- /***** D O U B L Y L I N K E D L I S T S *****/ |
- /***** *****/ |
- /***** *****/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- /*************************************************************************/ |
- |
-#undef FT_COMPONENT |
-#define FT_COMPONENT trace_list |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( FT_ListNode ) |
- FT_List_Find( FT_List list, |
- void* data ) |
- { |
- FT_ListNode cur; |
- |
- |
- cur = list->head; |
- while ( cur ) |
- { |
- if ( cur->data == data ) |
- return cur; |
- |
- cur = cur->next; |
- } |
- |
- return (FT_ListNode)0; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( void ) |
- FT_List_Add( FT_List list, |
- FT_ListNode node ) |
- { |
- FT_ListNode before = list->tail; |
- |
- |
- node->next = 0; |
- node->prev = before; |
- |
- if ( before ) |
- before->next = node; |
- else |
- list->head = node; |
- |
- list->tail = node; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( void ) |
- FT_List_Insert( FT_List list, |
- FT_ListNode node ) |
- { |
- FT_ListNode after = list->head; |
- |
- |
- node->next = after; |
- node->prev = 0; |
- |
- if ( !after ) |
- list->tail = node; |
- else |
- after->prev = node; |
- |
- list->head = node; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( void ) |
- FT_List_Remove( FT_List list, |
- FT_ListNode node ) |
- { |
- FT_ListNode before, after; |
- |
- |
- before = node->prev; |
- after = node->next; |
- |
- if ( before ) |
- before->next = after; |
- else |
- list->head = after; |
- |
- if ( after ) |
- after->prev = before; |
- else |
- list->tail = before; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( void ) |
- FT_List_Up( FT_List list, |
- FT_ListNode node ) |
- { |
- FT_ListNode before, after; |
- |
- |
- before = node->prev; |
- after = node->next; |
- |
- /* check whether we are already on top of the list */ |
- if ( !before ) |
- return; |
- |
- before->next = after; |
- |
- if ( after ) |
- after->prev = before; |
- else |
- list->tail = before; |
- |
- node->prev = 0; |
- node->next = list->head; |
- list->head->prev = node; |
- list->head = node; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( FT_Error ) |
- FT_List_Iterate( FT_List list, |
- FT_List_Iterator iterator, |
- void* user ) |
- { |
- FT_ListNode cur = list->head; |
- FT_Error error = FT_Err_Ok; |
- |
- |
- while ( cur ) |
- { |
- FT_ListNode next = cur->next; |
- |
- |
- error = iterator( cur, user ); |
- if ( error ) |
- break; |
- |
- cur = next; |
- } |
- |
- return error; |
- } |
- |
- |
- /* documentation is in ftlist.h */ |
- |
- FT_EXPORT_DEF( void ) |
- FT_List_Finalize( FT_List list, |
- FT_List_Destructor destroy, |
- FT_Memory memory, |
- void* user ) |
- { |
- FT_ListNode cur; |
- |
- |
- cur = list->head; |
- while ( cur ) |
- { |
- FT_ListNode next = cur->next; |
- void* data = cur->data; |
- |
- |
- if ( destroy ) |
- destroy( memory, data, user ); |
- |
- FT_FREE( cur ); |
- cur = next; |
- } |
- |
- list->head = 0; |
- list->tail = 0; |
- } |
- |
- |
- FT_BASE_DEF( FT_UInt32 ) |
- ft_highpow2( FT_UInt32 value ) |
- { |
- FT_UInt32 value2; |
- |
- |
- /* |
- * We simply clear the lowest bit in each iteration. When |
- * we reach 0, we know that the previous value was our result. |
- */ |
- for ( ;; ) |
- { |
- value2 = value & (value - 1); /* clear lowest bit */ |
- if ( value2 == 0 ) |
- break; |
- |
- value = value2; |
- } |
- return value; |
- } |
- |
- |
-/* END */ |