FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_string.c - third_party/github/FreeRTOS/FreeRTOS-Kernel - Git at Google

 /*
  * 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 */
 /*-----------------------------------------------------------*/
	/*
	* 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 */
	/-----------------------------------------------------------/