FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2024-12-26 03:17:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

staging: csr: remove CsrUtf8String typedef

Browse Source 
Use the in-kernel u8 type instead.

Cc: Mikko Virkkilä <mikko.virkkila@bluegiga.com>
Cc: Lauri Hintsala <Lauri.Hintsala@bluegiga.com>
Cc: Riku Mettälä <riku.mettala@bluegiga.com>
Cc: Veli-Pekka Peltola <veli-pekka.peltola@bluegiga.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Greg Kroah-Hartman 2012-07-20 12:19:55 -07:00
parent f58bfd88be
commit 7f5393ea2d
5 changed files with 37 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/staging/csr/csr_msgconv.h
View File

@ -74,7 +74,7 @@ void CsrMsgConvDeinit(void);
/* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */
u32 CsrCharStringSerLen(const CsrCharString *str);
u32 CsrUtf8StringSerLen(const CsrUtf8String *str);
u32 CsrUtf8StringSerLen(const u8 *str);
u32 CsrUtf16StringSerLen(const u16 *str);
/* Prototypes for primitive type serializers */
@ -83,7 +83,7 @@ void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value);
void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value);
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value);
void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value);
void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr);
void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value);
@ -93,7 +93,7 @@ void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset);
void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset);
void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset);
void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset);
void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset);
void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset);
void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset);

8
drivers/staging/csr/csr_serialize_primitive_types.c
View File

@ -55,9 +55,9 @@ void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset)
}
EXPORT_SYMBOL_GPL(CsrCharStringDes);
void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset)
void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset)
{
*value = (CsrUtf8String *) CsrStrDup((CsrCharString *) &buffer[*offset]);
*value = (u8 *) CsrStrDup((CsrCharString *) &buffer[*offset]);
*offset += CsrStrLen((CsrCharString *) *value) + 1;
}
@ -134,7 +134,7 @@ void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value)
}
EXPORT_SYMBOL_GPL(CsrCharStringSer);
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value)
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value)
{
CsrCharStringSer(buffer, offset, (CsrCharString *) value);
}
@ -185,7 +185,7 @@ u32 CsrCharStringSerLen(const CsrCharString *str)
}
}
u32 CsrUtf8StringSerLen(const CsrUtf8String *str)
u32 CsrUtf8StringSerLen(const u8 *str)
{
if (str)
{

1
drivers/staging/csr/csr_types.h
View File

@ -37,7 +37,6 @@ typedef u8 CsrBool;
/* String types */
typedef char CsrCharString;
typedef u8 CsrUtf8String;
/*
* 64-bit integers

22
drivers/staging/csr/csr_unicode.h
View File

@ -21,9 +21,9 @@ u16 *CsrUint32ToUtf16String(u32 number);
u32 CsrUtf16StringToUint32(const u16 *unicodeString);
u32 CsrUtf16StrLen(const u16 *unicodeString);
CsrUtf8String *CsrUtf16String2Utf8(const u16 *source);
u8 *CsrUtf16String2Utf8(const u16 *source);
u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String);
u16 *CsrUtf82Utf16String(const u8 *utf8String);
u16 *CsrUtf16StrCpy(u16 *target, const u16 *source);
u16 *CsrUtf16StringDuplicate(const u16 *source);
@ -38,9 +38,9 @@ u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2,
u16 *CsrUtf16String2XML(u16 *str);
u16 *CsrXML2Utf16String(u16 *str);
s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2);
s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count);
u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);
s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2);
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count);
u32 CsrUtf8StringLengthInBytes(const u8 *string);
/*******************************************************************************
@ -66,7 +66,7 @@ u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);
Returns target
*******************************************************************************/
CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count);
u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count);
/*******************************************************************************
@ -90,7 +90,7 @@ CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count);
Returns target
*******************************************************************************/
CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source);
u8 *CsrUtf8StrCpy(u8 *target, const u8 *source);
/*******************************************************************************
@ -116,7 +116,7 @@ CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source)
Returns target
*******************************************************************************/
CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);
/*******************************************************************************
@ -143,7 +143,7 @@ CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source
Returns target
*******************************************************************************/
CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count);
/*******************************************************************************
@ -163,9 +163,9 @@ CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *so
Returns a duplicate of source.
*******************************************************************************/
CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source);
u8 *CsrUtf8StrDup(const u8 *source);
CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4);
u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4);
/*
* UCS2

38
drivers/staging/csr/csr_utf16.c
View File

@ -253,9 +253,9 @@ u32 CsrUtf16StrLen(const u16 *unicodeString)
* Output: 0-terminated string of byte oriented UTF8 coded characters.
*
*********************************************************************************/
CsrUtf8String *CsrUtf16String2Utf8(const u16 *source)
u8 *CsrUtf16String2Utf8(const u16 *source)
{
CsrUtf8String *dest, *destStart = NULL;
u8 *dest, *destStart = NULL;
u32 i;
u32 ch;
u32 length;
@ -463,9 +463,9 @@ CsrUtf8String *CsrUtf16String2Utf8(const u16 *source)
TRUE if the given code unit is legal.
*****************************************************************************/
static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length)
static CsrBool isLegalUtf8(const u8 *codeUnit, u32 length)
{
const CsrUtf8String *srcPtr = codeUnit + length;
const u8 *srcPtr = codeUnit + length;
u8 byte;
switch (length) /* Everything falls through except case 1 */
@ -562,7 +562,7 @@ static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length)
* Output: 0-terminated string of UTF-16 characters.
*
*********************************************************************************/
u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String)
u16 *CsrUtf82Utf16String(const u8 *utf8String)
{
CsrSize i, length = 0;
CsrSize sourceLength;
@ -1016,17 +1016,17 @@ u16 *CsrXML2Utf16String(u16 *str)
return resultString;
}
s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2)
s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2)
{
return CsrStrCmp((const CsrCharString *) string1, (const CsrCharString *) string2);
}
s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count)
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count)
{
return CsrStrNCmp((const CsrCharString *) string1, (const CsrCharString *) string2, count);
}
u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)
u32 CsrUtf8StringLengthInBytes(const u8 *string)
{
CsrSize length = 0;
if (string)
@ -1036,12 +1036,12 @@ u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)
return (u32) length;
}
CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source)
u8 *CsrUtf8StrCpy(u8 *target, const u8 *source)
{
return (CsrUtf8String *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);
return (u8 *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);
}
CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count)
u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
{
CsrSize lastByte = count - 1;
@ -1070,12 +1070,12 @@ CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count)
return target;
}
CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count)
{
return (CsrUtf8String *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
return (u8 *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
}
CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)
{
CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
if (target[count - 1] != '\0')
@ -1085,14 +1085,14 @@ CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *so
return target;
}
CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source)
u8 *CsrUtf8StrDup(const u8 *source)
{
return (CsrUtf8String *) CsrStrDup((const CsrCharString *) source);
return (u8 *) CsrStrDup((const CsrCharString *) source);
}
CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4)
u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4)
{
CsrUtf8String *outputText;
u8 *outputText;
u32 textLen, textLen1, textLen2, textLen3, textLen4;
textLen1 = CsrUtf8StringLengthInBytes(inputText1);
@ -1107,7 +1107,7 @@ CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, co
return NULL;
}
outputText = (CsrUtf8String *) CsrPmemAlloc((textLen + 1) * sizeof(CsrUtf8String)); /* add space for 0-termination*/
outputText = (u8 *) CsrPmemAlloc((textLen + 1) * sizeof(u8)); /* add space for 0-termination*/
if (inputText1 != NULL)