Index: core/src/fxge/fx_freetype/fxft2.5.01/src/psaux/psconv.c |
diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/psaux/psconv.c b/core/src/fxge/fx_freetype/fxft2.5.01/src/psaux/psconv.c |
deleted file mode 100644 |
index c13d41b6a894e1538d40a0497d705c9feb2e7767..0000000000000000000000000000000000000000 |
--- a/core/src/fxge/fx_freetype/fxft2.5.01/src/psaux/psconv.c |
+++ /dev/null |
@@ -1,641 +0,0 @@ |
-/***************************************************************************/ |
-/* */ |
-/* psconv.c */ |
-/* */ |
-/* Some convenience conversions (body). */ |
-/* */ |
-/* Copyright 2006, 2008, 2009, 2012-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/psaux.h" |
-#include "../../include/freetype/internal/ftdebug.h" |
- |
-#include "psconv.h" |
-#include "psauxerr.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_psconv |
- |
- |
- /* The following array is used by various functions to quickly convert */ |
- /* digits (both decimal and non-decimal) into numbers. */ |
- |
-#if 'A' == 65 |
- /* ASCII */ |
- |
- static const FT_Char ft_char_table[128] = |
- { |
- /* 0x00 */ |
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, |
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, |
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, |
- }; |
- |
- /* no character >= 0x80 can represent a valid number */ |
-#define OP >= |
- |
-#endif /* 'A' == 65 */ |
- |
-#if 'A' == 193 |
- /* EBCDIC */ |
- |
- static const FT_Char ft_char_table[128] = |
- { |
- /* 0x80 */ |
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1, |
- -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, |
- -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, |
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1, |
- -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, |
- -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, |
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, |
- }; |
- |
- /* no character < 0x80 can represent a valid number */ |
-#define OP < |
- |
-#endif /* 'A' == 193 */ |
- |
- |
- FT_LOCAL_DEF( FT_Long ) |
- PS_Conv_Strtol( FT_Byte** cursor, |
- FT_Byte* limit, |
- FT_Long base ) |
- { |
- FT_Byte* p = *cursor; |
- |
- FT_Long num = 0; |
- FT_Bool sign = 0; |
- FT_Bool have_overflow = 0; |
- |
- FT_Long num_limit; |
- FT_Char c_limit; |
- |
- |
- if ( p >= limit ) |
- goto Bad; |
- |
- if ( base < 2 || base > 36 ) |
- { |
- FT_TRACE4(( "!!!INVALID BASE:!!!" )); |
- return 0; |
- } |
- |
- if ( *p == '-' || *p == '+' ) |
- { |
- sign = FT_BOOL( *p == '-' ); |
- |
- p++; |
- if ( p == limit ) |
- goto Bad; |
- } |
- |
- num_limit = 0x7FFFFFFFL / base; |
- c_limit = (FT_Char)( 0x7FFFFFFFL % base ); |
- |
- for ( ; p < limit; p++ ) |
- { |
- FT_Char c; |
- |
- |
- if ( IS_PS_SPACE( *p ) || *p OP 0x80 ) |
- break; |
- |
- c = ft_char_table[*p & 0x7f]; |
- |
- if ( c < 0 || c >= base ) |
- break; |
- |
- if ( num > num_limit || ( num == num_limit && c > c_limit ) ) |
- have_overflow = 1; |
- else |
- num = num * base + c; |
- } |
- |
- *cursor = p; |
- |
- if ( have_overflow ) |
- { |
- num = 0x7FFFFFFFL; |
- FT_TRACE4(( "!!!OVERFLOW:!!!" )); |
- } |
- |
- if ( sign ) |
- num = -num; |
- |
- return num; |
- |
- Bad: |
- FT_TRACE4(( "!!!END OF DATA:!!!" )); |
- return 0; |
- } |
- |
- |
- FT_LOCAL_DEF( FT_Long ) |
- PS_Conv_ToInt( FT_Byte** cursor, |
- FT_Byte* limit ) |
- |
- { |
- FT_Byte* p = *cursor; |
- FT_Byte* curp; |
- |
- FT_Long num; |
- |
- |
- curp = p; |
- num = PS_Conv_Strtol( &p, limit, 10 ); |
- |
- if ( p == curp ) |
- return 0; |
- |
- if ( p < limit && *p == '#' ) |
- { |
- p++; |
- |
- curp = p; |
- num = PS_Conv_Strtol( &p, limit, num ); |
- |
- if ( p == curp ) |
- return 0; |
- } |
- |
- *cursor = p; |
- |
- return num; |
- } |
- |
- |
- FT_LOCAL_DEF( FT_Fixed ) |
- PS_Conv_ToFixed( FT_Byte** cursor, |
- FT_Byte* limit, |
- FT_Long power_ten ) |
- { |
- FT_Byte* p = *cursor; |
- FT_Byte* curp; |
- // Fix the Vulnerability Report FoxIT Reader - MSVR-10-0077. |
- // We must use 64-bit integer to avoid overflow. If there is some 64-bit integer support. |
- // Since some platform doesn't support 64-bit integer, then use integer instead. |
-#if defined(FT_INT64) |
- FT_INT64 integral = 0; |
- FT_INT64 decimal = 0; |
-#else |
- FT_Long integral = 0; |
- FT_Long decimal = 0; |
- FT_Int temp0 = 65536; |
- FT_Int temp1 = power_ten; |
-#endif |
- FT_Long divider = 1; |
- |
- FT_Bool sign = 0; |
- FT_Bool have_overflow = 0; |
- FT_Bool have_underflow = 0; |
- |
- if ( p >= limit ) |
- goto Bad; |
- |
- if ( *p == '-' || *p == '+' ) |
- { |
- sign = FT_BOOL( *p == '-' ); |
- |
- p++; |
- if ( p == limit ) |
- goto Bad; |
- } |
- |
- /* read the integer part */ |
- if ( *p != '.' ) |
- { |
- curp = p; |
- |
- // Fix the Vulnerability Report FoxIT Reader - MSVR-10-0077. |
- // Limited to the fix-point mechanism, we have no choice now to crop the value domain. |
- // Do accurate overflow check if FT_INT64 supported, otherwise vague check. |
-#if defined(FT_INT64) |
- integral = ((FT_INT64)PS_Conv_ToInt( &p, limit )) << 16; |
-#else |
- // We use 'power_ten' and 2^16 to compute the coefficient. |
- //while ( temp1 > 0 ) { temp0 *= 10; temp1 --; } |
- //while ( temp1 < 0 ) { temp0 /= 10; temp1 ++; } |
- |
- integral = PS_Conv_ToInt( &p, limit ); |
- if ( p == curp ) |
- return 0; |
- if ( integral > 0x7FFF ) |
- have_overflow = 1; |
- else |
- integral = integral << 16; |
-#endif |
- } |
- |
- /* read the decimal part */ |
- if ( p < limit && *p == '.' ) |
- { |
- p++; |
- |
- for ( ; p < limit; p++ ) |
- { |
- FT_Char c; |
- |
- |
- if ( IS_PS_SPACE( *p ) || *p OP 0x80 ) |
- break; |
- |
- c = ft_char_table[*p & 0x7f]; |
- |
- if ( c < 0 || c >= 10 ) |
- break; |
- |
- if ( decimal < 0xCCCCCCCL ) |
- { |
- decimal = decimal * 10 + c; |
- |
- if ( !integral && power_ten > 0 ) |
- power_ten--; |
- else |
- divider *= 10; |
- } |
- } |
- } |
- |
- /* read exponent, if any */ |
- if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) ) |
- { |
- FT_Long exponent; |
- |
- |
- p++; |
- |
- curp = p; |
- exponent = PS_Conv_ToInt( &p, limit ); |
- |
- if ( curp == p ) |
- return 0; |
- |
- /* arbitrarily limit exponent */ |
- if ( exponent > 1000 ) |
- have_overflow = 1; |
- else if ( exponent < -1000 ) |
- have_underflow = 1; |
- else |
- power_ten += exponent; |
- } |
- |
- *cursor = p; |
- |
- if ( !integral && !decimal ) |
- return 0; |
- |
- if ( have_overflow ) |
- goto Overflow; |
- if ( have_underflow ) |
- goto Underflow; |
- |
- while ( power_ten > 0 ) |
- { |
- if ( integral >= 0xCCCCCCCL ) |
- goto Overflow; |
- integral *= 10; |
- |
- if ( decimal >= 0xCCCCCCCL ) |
- { |
- if ( divider == 1 ) |
- goto Overflow; |
- divider /= 10; |
- } |
- else |
- decimal *= 10; |
- |
- power_ten--; |
- } |
- |
- while ( power_ten < 0 ) |
- { |
- integral /= 10; |
- if ( divider < 0xCCCCCCCL ) |
- divider *= 10; |
- else |
- decimal /= 10; |
- |
- if ( !integral && !decimal ) |
- goto Underflow; |
- |
- power_ten++; |
- } |
- |
-// Fix the Vulnerability Report FoxIT Reader - MSVR-10-0077. |
- // Limited to the fix-point mechanism, we have no choice now to crop the value domain. |
- // Do accurate overflow check if FT_INT64 supported, otherwise ignore the check at this moment. |
- // Since there is also a check using divider < 10000000L. |
-#if defined(FT_INT64) |
- if ( decimal ) { |
- integral += FT_DivFix( (FT_Long)decimal, divider ); |
- } |
- if ( integral > 2147483647) integral = 2147483647; |
-#else |
- if ( decimal ) { |
- integral += FT_DivFix( decimal, divider ); |
- } |
-#endif |
- |
- |
- Exit: |
- if ( sign ) |
- integral = -integral; |
- |
- return (FT_Long)integral; |
- |
- Bad: |
- FT_TRACE4(( "!!!END OF DATA:!!!" )); |
- return 0; |
- |
- Overflow: |
- integral = 0x7FFFFFFFL; |
- FT_TRACE4(( "!!!OVERFLOW:!!!" )); |
- goto Exit; |
- |
- Underflow: |
- FT_TRACE4(( "!!!UNDERFLOW:!!!" )); |
- return 0; |
- } |
- |
- |
-#if 0 |
- FT_LOCAL_DEF( FT_UInt ) |
- PS_Conv_StringDecode( FT_Byte** cursor, |
- FT_Byte* limit, |
- FT_Byte* buffer, |
- FT_Offset n ) |
- { |
- FT_Byte* p; |
- FT_UInt r = 0; |
- |
- |
- for ( p = *cursor; r < n && p < limit; p++ ) |
- { |
- FT_Byte b; |
- |
- |
- if ( *p != '\\' ) |
- { |
- buffer[r++] = *p; |
- |
- continue; |
- } |
- |
- p++; |
- |
- switch ( *p ) |
- { |
- case 'n': |
- b = '\n'; |
- break; |
- case 'r': |
- b = '\r'; |
- break; |
- case 't': |
- b = '\t'; |
- break; |
- case 'b': |
- b = '\b'; |
- break; |
- case 'f': |
- b = '\f'; |
- break; |
- case '\r': |
- p++; |
- if ( *p != '\n' ) |
- { |
- b = *p; |
- |
- break; |
- } |
- /* no break */ |
- case '\n': |
- continue; |
- break; |
- default: |
- if ( IS_PS_DIGIT( *p ) ) |
- { |
- b = *p - '0'; |
- |
- p++; |
- |
- if ( IS_PS_DIGIT( *p ) ) |
- { |
- b = b * 8 + *p - '0'; |
- |
- p++; |
- |
- if ( IS_PS_DIGIT( *p ) ) |
- b = b * 8 + *p - '0'; |
- else |
- { |
- buffer[r++] = b; |
- b = *p; |
- } |
- } |
- else |
- { |
- buffer[r++] = b; |
- b = *p; |
- } |
- } |
- else |
- b = *p; |
- break; |
- } |
- |
- buffer[r++] = b; |
- } |
- |
- *cursor = p; |
- |
- return r; |
- } |
-#endif /* 0 */ |
- |
- |
- FT_LOCAL_DEF( FT_UInt ) |
- PS_Conv_ASCIIHexDecode( FT_Byte** cursor, |
- FT_Byte* limit, |
- FT_Byte* buffer, |
- FT_Offset n ) |
- { |
- FT_Byte* p; |
- FT_UInt r = 0; |
- FT_UInt w = 0; |
- FT_UInt pad = 0x01; |
- |
- |
- n *= 2; |
- |
-#if 1 |
- |
- p = *cursor; |
- |
- if ( p >= limit ) |
- return 0; |
- |
- if ( n > (FT_UInt)( limit - p ) ) |
- n = (FT_UInt)( limit - p ); |
- |
- /* we try to process two nibbles at a time to be as fast as possible */ |
- for ( ; r < n; r++ ) |
- { |
- FT_UInt c = p[r]; |
- |
- |
- if ( IS_PS_SPACE( c ) ) |
- continue; |
- |
- if ( c OP 0x80 ) |
- break; |
- |
- c = ft_char_table[c & 0x7F]; |
- if ( (unsigned)c >= 16 ) |
- break; |
- |
- pad = ( pad << 4 ) | c; |
- if ( pad & 0x100 ) |
- { |
- buffer[w++] = (FT_Byte)pad; |
- pad = 0x01; |
- } |
- } |
- |
- if ( pad != 0x01 ) |
- buffer[w++] = (FT_Byte)( pad << 4 ); |
- |
- *cursor = p + r; |
- |
- return w; |
- |
-#else /* 0 */ |
- |
- for ( r = 0; r < n; r++ ) |
- { |
- FT_Char c; |
- |
- |
- if ( IS_PS_SPACE( *p ) ) |
- continue; |
- |
- if ( *p OP 0x80 ) |
- break; |
- |
- c = ft_char_table[*p & 0x7f]; |
- |
- if ( (unsigned)c >= 16 ) |
- break; |
- |
- if ( r & 1 ) |
- { |
- *buffer = (FT_Byte)(*buffer + c); |
- buffer++; |
- } |
- else |
- *buffer = (FT_Byte)(c << 4); |
- |
- r++; |
- } |
- |
- *cursor = p; |
- |
- return ( r + 1 ) / 2; |
- |
-#endif /* 0 */ |
- |
- } |
- |
- |
- FT_LOCAL_DEF( FT_UInt ) |
- PS_Conv_EexecDecode( FT_Byte** cursor, |
- FT_Byte* limit, |
- FT_Byte* buffer, |
- FT_Offset n, |
- FT_UShort* seed ) |
- { |
- FT_Byte* p; |
- FT_UInt r; |
- FT_UInt s = *seed; |
- |
- |
-#if 1 |
- |
- p = *cursor; |
- |
- if ( p >= limit ) |
- return 0; |
- |
- if ( n > (FT_UInt)(limit - p) ) |
- n = (FT_UInt)(limit - p); |
- |
- for ( r = 0; r < n; r++ ) |
- { |
- FT_UInt val = p[r]; |
- FT_UInt b = ( val ^ ( s >> 8 ) ); |
- |
- |
- s = ( (val + s)*52845U + 22719 ) & 0xFFFFU; |
- buffer[r] = (FT_Byte) b; |
- } |
- |
- *cursor = p + n; |
- *seed = (FT_UShort)s; |
- |
-#else /* 0 */ |
- |
- for ( r = 0, p = *cursor; r < n && p < limit; r++, p++ ) |
- { |
- FT_Byte b = (FT_Byte)( *p ^ ( s >> 8 ) ); |
- |
- |
- s = (FT_UShort)( ( *p + s ) * 52845U + 22719 ); |
- *buffer++ = b; |
- } |
- *cursor = p; |
- *seed = s; |
- |
-#endif /* 0 */ |
- |
- return r; |
- } |
- |
-FT_LOCAL_DEF( FT_Bool ) |
- xyq_PS_Conv_ToInt( FT_Byte** cursor, |
- FT_Byte* limit, FT_Long* val ) |
- |
- { |
- FT_Byte first_char = **cursor; |
- if (first_char == '+' || first_char == '-' || (first_char >= '0' && first_char <= '9')) { |
- *val = PS_Conv_ToInt(cursor, limit); |
- return 1; |
- } |
- return 0; |
- } |
- |
-/* END */ |
- |