diff options
Diffstat (limited to 'FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c')
| -rw-r--r-- | FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c | 716 |
1 files changed, 716 insertions, 0 deletions
diff --git a/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c b/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c new file mode 100644 index 000000000..7c941914f --- /dev/null +++ b/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c @@ -0,0 +1,716 @@ +/*
+ * FreeRTOS+FAT build 191128 - Note: FreeRTOS+FAT is still in the lab!
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Authors include James Walmsley, Hein Tibosch and Richard Barry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ *
+ */
+
+/**
+ * @file ff_string.c
+ * @ingroup STRING
+ *
+ * @defgroup STRING FreeRTOS+FAT String Library
+ * @brief Portable String Library for FreeRTOS+FAT
+ *
+ *
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "ff_headers.h"
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ #include <wchar.h>
+ #include <wctype.h>
+#endif
+
+/*
+ * These will eventually be moved into a platform independent string
+ * library. Which will be optional. (To allow the use of system specific versions).
+ */
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ void FF_cstrntowcs( FF_T_WCHAR *wcsDest, const int8_t *szpSource, uint32_t ulLength )
+ {
+ while( ( *szpSource != '\0' ) && ( ulLength-- != 0 ) )
+ {
+ *( wcsDest++ ) = *( szpSource++ );
+ }
+ *wcsDest = '\0';
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+/*-----------------------------------------------------------*/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ void FF_cstrtowcs( FF_T_WCHAR *wcsDest, const int8_t *szpSource )
+ {
+ while( *szpSource != '\0' )
+ {
+ *wcsDest++ = ( FF_T_WCHAR ) *( szpSource++ );
+ }
+ *wcsDest = '\0';
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+/*-----------------------------------------------------------*/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ void FF_wcstocstr( int8_t *szpDest, const FF_T_WCHAR *wcsSource )
+ {
+ while( *wcsSource != '\0' )
+ {
+ *szpDest++ = ( int8_t )*( wcsSource++ );
+ }
+ *szpDest = '\0';
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+/*-----------------------------------------------------------*/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ void FF_wcsntocstr( int8_t *szpDest, const FF_T_WCHAR *wcsSource, uint32_t ulLength )
+ {
+ while( ( *wcsSource != '\0' ) && ( ulLength-- != 0 ) )
+ {
+ *( szpDest++ ) = ( int8_t ) *( wcsSource++ );
+ }
+ *szpDest = '\0';
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+/*-----------------------------------------------------------*/
+
+/*-----------------------------------------------------------*/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
+ void FF_toupper( FF_T_WCHAR *string, uint32_t ulLength )
+ {
+ uint32_t i;
+
+ for( i = 0; i < ulLength; i++ )
+ {
+ string[ i ] = towupper( string[ i ] );
+ }
+ }
+ /*-----------------------------------------------------------*/
+
+ void FF_tolower( FF_T_WCHAR *string, uint32_t ulLength )
+ {
+ uint32_t i;
+ for( i = 0; i < ulLength; i++ )
+ {
+ string[ i ] = towlower( string[ i ] );
+ }
+ }
+ /*-----------------------------------------------------------*/
+
+#else /* ffconfigUNICODE_UTF16_SUPPORT */
+ void FF_toupper( char *string, uint32_t ulLength )
+ {
+ uint32_t i;
+
+ for( i = 0; i < ulLength; i++ )
+ {
+ if( ( string[ i ] >= 'a' ) && ( string[ i ] <= 'z' ) )
+ {
+ string[ i ] -= 32;
+ }
+ if( string[ i ] == '\0' )
+ {
+ break;
+ }
+ }
+ }
+ /*-----------------------------------------------------------*/
+
+ void FF_tolower( char *string, uint32_t ulLength )
+ {
+ uint32_t i;
+
+ for( i = 0; i < ulLength; i++ )
+ {
+ if( ( string[ i ] >= 'A' ) && ( string[ i ] <= 'Z' ) )
+ {
+ string[ i ] += 32;
+ }
+ if( string[ i ] == '\0' )
+ {
+ break;
+ }
+ }
+ }
+ /*-----------------------------------------------------------*/
+
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+
+
+/**
+ * @private
+ * @brief Compares 2 strings for the specified length, and returns pdTRUE is they are identical
+ * otherwise pdFALSE is returned.
+ *
+ **/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT == 0 )
+ BaseType_t FF_strmatch( const char *str1, const char *str2, BaseType_t xLength )
+ {
+ register BaseType_t i;
+ register char char1, char2;
+
+ if( xLength == 0 )
+ {
+ xLength = strlen( str1 );
+ if( xLength != ( BaseType_t )strlen( str2 ) )
+ {
+ return pdFALSE;
+ }
+ }
+
+ for( i = 0; i < xLength; i++ )
+ {
+ char1 = str1[ i ];
+ char2 = str2[ i ];
+ if( ( char1 >= 'A' ) && ( char1 <= 'Z' ) )
+ {
+ char1 += 32;
+ }
+ if( ( char2 >= 'A' ) && ( char2 <= 'Z' ) )
+ {
+ char2 += 32;
+ }
+
+ if( char1 != char2 )
+ {
+ return pdFALSE;
+ }
+ }
+
+ return pdTRUE;
+ }
+#else /* ffconfigUNICODE_UTF16_SUPPORT */
+ BaseType_t FF_strmatch( const FF_T_WCHAR *str1, const FF_T_WCHAR *str2, BaseType_t xLength )
+ {
+ register BaseType_t i;
+ register FF_T_WCHAR char1, char2;
+
+ if( xLength == 0 )
+ {
+ xLength = wcslen( str1 );
+ if( xLength != wcslen( str2 ) )
+ {
+ return pdFALSE;
+ }
+ }
+
+ for( i = 0; i < xLength; i++ )
+ {
+ char1 = towlower( str1[ i ] );
+ char2 = towlower( str2[ i ] );
+ if( char1 != char2 )
+ {
+ return pdFALSE;
+ }
+ }
+
+ return pdTRUE;
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+
+/**
+ * @private
+ * @brief A re-entrant Strtok function. No documentation is provided :P
+ * Use at your own risk. (This is for FreeRTOS+FAT's use only).
+ **/
+
+#if( ffconfigUNICODE_UTF16_SUPPORT == 0 )
+ char *FF_strtok( const char *string, char *token, uint16_t *tokenNumber, BaseType_t *last, BaseType_t xLength )
+ {
+ uint16_t i,y, tokenStart, tokenEnd = 0;
+
+ i = 0;
+ y = 0;
+
+ if( ( string[ i ] == '\\' ) || ( string[ i ] == '/' ) )
+ {
+ i++;
+ }
+
+ tokenStart = i;
+
+ while( i < xLength )
+ {
+ if( ( string[ i ] == '\\' ) || ( string[ i ] == '/' ) )
+ {
+ y++;
+ if( y == *tokenNumber )
+ {
+ tokenStart = ( uint16_t )( i + 1 );
+ }
+ if( y == ( *tokenNumber + 1 ) )
+ {
+ tokenEnd = i;
+ break;
+ }
+ }
+ i++;
+ }
+
+ if( tokenEnd == 0 )
+ {
+ if( *last == pdTRUE )
+ {
+ return NULL;
+ }
+ else
+ {
+ *last = pdTRUE;
+ }
+ tokenEnd = i;
+ }
+ if( ( tokenEnd - tokenStart ) < ffconfigMAX_FILENAME )
+ {
+ memcpy( token, ( string + tokenStart ), ( uint32_t )( tokenEnd - tokenStart ) );
+ token[ tokenEnd - tokenStart ] = '\0';
+ }
+ else
+ {
+ memcpy( token, ( string + tokenStart ), ( uint32_t )( ffconfigMAX_FILENAME ) );
+ token[ ffconfigMAX_FILENAME - 1 ] = '\0';
+ }
+ /*token[tokenEnd - tokenStart] = '\0'; */
+ *tokenNumber += 1;
+
+ return token;
+ }
+#else /* ffconfigUNICODE_UTF16_SUPPORT */
+ FF_T_WCHAR *FF_strtok( const FF_T_WCHAR *string, FF_T_WCHAR *token, uint16_t *tokenNumber, BaseType_t *last, BaseType_t xLength )
+ {
+ uint16_t i,y, tokenStart, tokenEnd = 0;
+
+ i = 0;
+ y = 0;
+
+ if( ( string[ i ] == '\\' ) || ( string[ i ] == '/' ) )
+ {
+ i++;
+ }
+
+ tokenStart = i;
+
+ while( i < xLength )
+ {
+ if( ( string[ i ] == '\\' ) || ( string[ i ] == '/' ) )
+ {
+ y++;
+ if( y == *tokenNumber )
+ {
+ tokenStart = ( uint16_t ) ( i + 1 );
+ }
+ if( y == ( *tokenNumber + 1 ) )
+ {
+ tokenEnd = i;
+ break;
+ }
+ }
+ i++;
+ }
+
+ if( tokenEnd == 0 )
+ {
+ if( *last == pdTRUE )
+ {
+ return NULL;
+ }
+ else
+ {
+ *last = pdTRUE;
+ }
+ tokenEnd = i;
+ }
+ if( ( tokenEnd - tokenStart ) < ffconfigMAX_FILENAME )
+ {
+ memcpy( token, ( string + tokenStart ), ( uint32_t )( tokenEnd - tokenStart ) * sizeof( FF_T_WCHAR ) );
+ token[ tokenEnd - tokenStart ] = '\0';
+ }
+ else
+ {
+ memcpy( token, ( string + tokenStart ), ( uint32_t )( ffconfigMAX_FILENAME ) * sizeof( FF_T_WCHAR ) );
+ token[ ffconfigMAX_FILENAME - 1 ] = '\0';
+ }
+ /*token[tokenEnd - tokenStart] = '\0'; */
+ *tokenNumber += 1;
+
+ return token;
+ }
+#endif /* ffconfigUNICODE_UTF16_SUPPORT */
+
+/* UTF-8 Routines */
+
+/*
+ UCS-4 range (hex.) UTF-8 octet sequence (binary)
+ 0000 0000-0000 007F 0xxxxxxx
+ 0000 0080-0000 07FF 110xxxxx 10xxxxxx
+ 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
+
+ 0001 0000-001F FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ 0020 0000-03FF FFFF 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx -- We don't encode these because we won't receive them. (Invalid UNICODE).
+ 0400 0000-7FFF FFFF 1111110x 10xxxxxx ... 10xxxxxx -- We don't encode these because we won't receive them. (Invalid UNICODE).
+*/
+
+#if ( ( ffconfigUNICODE_UTF16_SUPPORT != 0 ) && ( WCHAR_MAX > 0xFFFF ) ) || ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
+ UBaseType_t FF_GetUtf16SequenceLen( uint16_t usLeadChar )
+ {
+ UBaseType_t uxReturn;
+ if( ( usLeadChar & 0xFC00 ) == 0xD800 )
+ {
+ uxReturn = 2;
+ }
+ else
+ {
+ uxReturn = 1;
+ }
+
+ return uxReturn;
+ } /* FF_GetUtf16SequenceLen() */
+#endif
+/*-----------------------------------------------------------*/
+
+/*
+ Returns the number of UTF-8 units read.
+ Will not exceed ulSize UTF-16 units. (ulSize * 2 bytes).
+*/
+/*
+ UCS-4 range (hex.) UTF-8 octet sequence (binary)
+ 0000 0000-0000 007F 0xxxxxxx
+ 0000 0080-0000 07FF 110xxxxx 10xxxxxx
+ 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
+
+ 0001 0000-001F FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ 0020 0000-03FF FFFF 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx -- We don't encode these because we won't receive them. (Invalid UNICODE).
+ 0400 0000-7FFF FFFF 1111110x 10xxxxxx ... 10xxxxxx -- We don't encode these because we won't receive them. (Invalid UNICODE).
+*/
+#if ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
+ int32_t FF_Utf8ctoUtf16c( uint16_t *utf16Dest, const uint8_t *utf8Source, uint32_t ulSize )
+ {
+ uint32_t ulUtf32char;
+ uint16_t utf16Source = 0;
+ register int32_t lSequenceNumber = 0;
+
+ /* Count number of set bits before a zero. */
+ while( ( ( *utf8Source != '\0' ) & ( 0x80 >> ( lSequenceNumber ) ) ) )
+ {
+ lSequenceNumber++;
+ }
+
+ if( lSequenceNumber == 0UL )
+ {
+ lSequenceNumber++;
+ }
+
+ if( ulSize == 0UL )
+ {
+ /* Returned value becomes an error, with the highest bit set. */
+ lSequenceNumber = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF8CTOUTF16C;
+ }
+ else
+ {
+ switch( lSequenceNumber )
+ {
+ case 1:
+ utf16Source = (uint16_t) *utf8Source;
+ memcpy(utf16Dest,&utf16Source,sizeof(uint16_t));
+ break;
+
+ case 2:
+ utf16Source =(uint16_t) ((*utf8Source & 0x1F) << 6) | ((*(utf8Source + 1) & 0x3F));
+ memcpy(utf16Dest,&utf16Source,sizeof(uint16_t));
+ break;
+
+ case 3:
+ utf16Source =(uint16_t) ((*utf8Source & 0x0F) << 12) | ((*(utf8Source + 1) & 0x3F) << 6) | ((*(utf8Source + 2) & 0x3F));
+ memcpy(utf16Dest,&utf16Source,sizeof(uint16_t));
+ break;
+
+ case 4:
+ if( ulSize < 2 )
+ {
+ /* Returned value becomes an error. */
+ lSequenceNumber = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF8CTOUTF16C;
+ }
+ else
+ {
+ /* Convert to UTF-32 and then into UTF-16 */
+ ulUtf32char = ( uint16_t )
+ ( ( *utf8Source & 0x0F ) << 18 ) |
+ ( ( *( utf8Source + 1 ) & 0x3F ) << 12 ) |
+ ( ( *( utf8Source + 2 ) & 0x3F ) << 6 ) |
+ ( ( *( utf8Source + 3 ) & 0x3F ) );
+
+ utf16Source = ( uint16_t ) ( ( ( ulUtf32char - 0x10000 ) & 0xFFC00 ) >> 10 ) | 0xD800;
+ memcpy( utf16Dest, &utf16Source, sizeof( uint16_t ) );
+ utf16Source = ( uint16_t ) ( ( ( ulUtf32char - 0x10000 ) & 0x003FF ) >> 00 ) | 0xDC00;
+ memcpy( utf16Dest + 1, &utf16Source, sizeof( uint16_t ) );
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return lSequenceNumber;
+ } /* FF_Utf8ctoUtf16c() */
+#endif /* ffconfigUNICODE_UTF8_SUPPORT */
+
+/*-----------------------------------------------------------*/
+
+/*
+ Returns the number of UTF-8 units required to encode the UTF-16 sequence.
+ Will not exceed ulSize UTF-8 units. (ulSize * 1 bytes).
+*/
+#if ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
+ int32_t FF_Utf16ctoUtf8c( uint8_t *utf8Dest, const uint16_t *utf16Source, uint32_t ulSize )
+ {
+ uint32_t ulUtf32char;
+ uint16_t ulUtf16char;
+ int32_t lReturn = 0L;
+
+ do
+ {
+ if( ulSize == 0UL )
+ {
+ lReturn = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF16CTOUTF8C;
+ break;
+ }
+ memcpy( &ulUtf16char, utf16Source, sizeof( uint16_t ) );
+
+ /* A surrogate sequence was encountered. Must transform to UTF32 first. */
+ if( ( ulUtf16char & 0xF800) == 0xD800 )
+ {
+ ulUtf32char = ( ( uint32_t ) ( ulUtf16char & 0x003FF ) << 10 ) + 0x10000;
+
+ memcpy( &ulUtf16char, utf16Source + 1, sizeof( uint16_t ) );
+ if( ( ulUtf16char & 0xFC00 ) != 0xDC00 )
+ {
+ /* Invalid UTF-16 sequence. */
+ lReturn = FF_ERR_UNICODE_INVALID_SEQUENCE | FF_UTF16CTOUTF8C;
+ break;
+ }
+ ulUtf32char |= ( ( uint32_t ) ( ulUtf16char & 0x003FF ) );
+ }
+ else
+ {
+ ulUtf32char = ( uint32_t ) ulUtf16char;
+ }
+
+ /* Now convert to the UTF-8 sequence. */
+ /* Single byte UTF-8 sequence. */
+ if( ulUtf32char < 0x00000080 )
+ {
+ *( utf8Dest + 0 ) = ( uint8_t )ulUtf32char;
+ lReturn = 1;
+ break;
+ }
+
+ /* Double byte UTF-8 sequence. */
+ if( ulUtf32char < 0x00000800 )
+ {
+ if( ulSize < 2 )
+ {
+ lReturn = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF16CTOUTF8C;
+ }
+ else
+ {
+ *( utf8Dest + 0 ) = ( uint8_t ) ( 0xC0 | ( ( ulUtf32char >> 6 ) & 0x1F ) );
+ *( utf8Dest + 1 ) = ( uint8_t ) ( 0x80 | ( ( ulUtf32char >> 0 ) & 0x3F ) );
+ lReturn = 2;
+ }
+ break;
+ }
+
+ /* Triple byte UTF-8 sequence. */
+ if( ulUtf32char < 0x00010000 )
+ {
+ if( ulSize < 3 )
+ {
+ lReturn = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF16CTOUTF8C;
+ }
+ else
+ {
+ *( utf8Dest + 0 ) = ( uint8_t ) ( 0xE0 | ( ( ulUtf32char >> 12 ) & 0x0F ) );
+ *( utf8Dest + 1 ) = ( uint8_t ) ( 0x80 | ( ( ulUtf32char >> 6 ) & 0x3F ) );
+ *( utf8Dest + 2 ) = ( uint8_t ) ( 0x80 | ( ( ulUtf32char >> 0 ) & 0x3F ) );
+ lReturn = 3;
+ }
+ break;
+ }
+
+ /* Quadruple byte UTF-8 sequence. */
+ if( ulUtf32char < 0x00200000 )
+ {
+ if( ulSize < 4 )
+ {
+ lReturn = FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF16CTOUTF8C;
+ }
+ else
+ {
+ *( utf8Dest + 0 ) = ( uint8_t ) (0xF0 | ( ( ulUtf32char >> 18 ) & 0x07 ) );
+ *( utf8Dest + 1 ) = ( uint8_t ) (0x80 | ( ( ulUtf32char >> 12 ) & 0x3F ) );
+ *( utf8Dest + 2 ) = ( uint8_t ) (0x80 | ( ( ulUtf32char >> 6 ) & 0x3F ) );
+ *( utf8Dest + 3 ) = ( uint8_t ) (0x80 | ( ( ulUtf32char >> 0 ) & 0x3F ) );
+ lReturn = 4;
+ }
+ break;
+ }
+ lReturn = FF_ERR_UNICODE_INVALID_CODE | FF_UTF16CTOUTF8C; /* Invalid Character */
+ }
+ while( pdFALSE );
+
+ return lReturn;
+ } /* FF_Utf16ctoUtf8c() */
+#endif /* ffconfigUNICODE_UTF8_SUPPORT */
+/*-----------------------------------------------------------*/
+
+/* UTF-16 Support Functions */
+
+/* Converts a UTF-32 Character into its equivalent UTF-16 sequence. */
+#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) && ( WCHAR_MAX > 0xFFFF )
+ int32_t FF_Utf32ctoUtf16c( uint16_t *utf16Dest, uint32_t utf32char, uint32_t ulSize )
+ {
+ int32_t lReturn;
+ /* Check that its a valid UTF-32 wide-char! */
+
+ /* This range is not a valid Unicode code point. */
+ if( ( utf32char >= 0xD800 ) && ( utf32char <= 0xDFFF ) )
+ {
+ lReturn = FF_ERR_UNICODE_INVALID_CODE | FF_UTF32CTOUTF16C; /* Invalid character. */
+ }
+ else if( utf32char < 0x10000 )
+ {
+ *utf16Dest = (uint16_t) utf32char; /* Simple conversion! Char comes within UTF-16 space (without surrogates). */
+ lReturn = 1;
+ }
+ else if( ulSize < 2 )
+ {
+ lReturn FF_ERR_UNICODE_DEST_TOO_SMALL | FF_UTF32CTOUTF16C; /* Not enough UTF-16 units to record this character. */
+ }
+ else if( utf32char < 0x00200000 )
+ {
+ /* Conversion to a UTF-16 Surrogate pair! */
+ /*valueImage = utf32char - 0x10000; */
+ *( utf16Dest + 0 ) = ( uint16_t ) ( ( ( utf32char - 0x10000 ) & 0xFFC00 ) >> 10 ) | 0xD800;
+ *( utf16Dest + 1 ) = ( uint16_t ) ( ( ( utf32char - 0x10000 ) & 0x003FF ) >> 00 ) | 0xDC00;
+
+ lReturn = 2; /* Surrogate pair encoded value. */
+ }
+ else
+ {
+ /* Invalid Character */
+ lReturn = FF_ERR_UNICODE_INVALID_CODE | FF_UTF32CTOUTF16C;
+ }
+
+ return lReturn;
+ } /* FF_Utf32ctoUtf16c() */
+#endif /* #if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) && ( WCHAR_MAX > 0xFFFF ) */
+/*-----------------------------------------------------------*/
+
+/* Converts a UTF-16 sequence into its equivalent UTF-32 code point. */
+#if( ffconfigNOT_USED_FOR_NOW != 0 )
+ int32_t FF_Utf16ctoUtf32c( uint32_t *utf32Dest, const uint16_t *utf16Source )
+ {
+ int32_t lReturn;
+
+ /*Not a surrogate sequence. */
+ if( ( *utf16Source & 0xFC00 ) != 0xD800 )
+ {
+ *utf32Dest = ( uint32_t )*utf16Source;
+ lReturn = 1; /* A single UTF-16 item was used to represent the character. */
+ }
+ else
+ {
+ *utf32Dest = ( ( uint32_t) ( * ( utf16Source + 0 ) & 0x003FF ) << 10 ) + 0x10000;
+ if( ( *(utf16Source + 1) & 0xFC00 ) != 0xDC00 )
+ {
+ lReturn = FF_ERR_UNICODE_INVALID_SEQUENCE | FF_UTF16CTOUTF32C; /* Invalid UTF-16 sequence. */
+ }
+ else
+ {
+ *utf32Dest |= ( ( uint32_t ) ( *( utf16Source + 1 ) & 0x003FF ) );
+ lReturn = 2; /* 2 utf-16 units make up the Unicode code-point. */
+ }
+ }
+
+ return lReturn;
+ } /* FF_Utf16ctoUtf32c() */
+#endif /* ffconfigNOT_USED_FOR_NOW */
+/*-----------------------------------------------------------*/
+
+/*
+ Returns the total number of UTF-16 items required to represent
+ the provided UTF-32 string in UTF-16 form.
+*/
+/*
+UBaseType_t FF_Utf32GetUtf16Len( const uint32_t *utf32String )
+{
+ UBaseType_t utf16len = 0;
+
+ while( *utf32String )
+ {
+ if( *utf32String++ <= 0xFFFF )
+ {
+ utf16len++;
+ }
+ else
+ {
+ utf16len += 2;
+ }
+ }
+
+ return utf16len;
+}
+*/
+/*-----------------------------------------------------------*/
+
+
+/* String conversions */
+
+#if( ffconfigNOT_USED_FOR_NOW != 0 )
+ int32_t FF_Utf32stoUtf8s( uint8_t *Utf8String, uint32_t *Utf32String )
+ {
+ int i = 0,y = 0;
+
+ uint16_t utf16buffer[ 2 ];
+
+ while( Utf32String[ i ] != '\0' )
+ {
+ /* Convert to a UTF16 char. */
+ FF_Utf32ctoUtf16c( utf16buffer, Utf32String[ i ], 2 );
+ /* Now convert the UTF16 to UTF8 sequence. */
+ y += FF_Utf16ctoUtf8c( &Utf8String[ y ], utf16buffer, 4 );
+ i++;
+ }
+
+ Utf8String[ y ] = '\0';
+
+ return 0;
+ } /* FF_Utf32stoUtf8s() */
+#endif /* ffconfigNOT_USED_FOR_NOW */
+/*-----------------------------------------------------------*/
|