Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 310d5940 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

staging: csr: remove CsrStrNcpy 



A few other functions were using it, but no one was calling them, so
remove them as well:
	CsrUtf8StrNCpy()
	CsrUtf8StrNCpyZero()
	CsrUtf8StringConcatenateTexts()

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: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent b6e6e3a8

drivers/staging/csr/csr_unicode.h

+0 −55
Original line number Diff line number Diff line
@@ -66,59 +66,6 @@ u32 CsrUtf8StringLengthInBytes(const u8 *string); 
*******************************************************************************/

u8 *CsrUtf8StrTruncate(u8 *target, size_t count);



/*******************************************************************************



    NAME

        CsrUtf8StrNCpy



    DESCRIPTION

        Copies the first count bytes of source to target. If the end of the

        source UTF-8 string (which is signaled by a null-character) is found

        before count bytes have been copied, target is padded with null

        characters until a total of count bytes have been written to it.



        No null-character is implicitly appended to the end of target, so target

        will only be null-terminated if the length of the UTF-8 string in source

        is less than count.



    PARAMETERS

        target - Pointer to the target memory where the content is to be copied.

        source - UTF-8 string to be copied.

        count - Maximum number of bytes to be written to target.



    RETURNS

        Returns target



*******************************************************************************/

u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count);



/*******************************************************************************



    NAME

        CsrUtf8StrNCpyZero



    DESCRIPTION

        Equivalent to CsrUtf8StrNCpy, but if the length of source is equal to or

        greater than count the target string is truncated on a UTF-8 character

        boundary by writing a null character somewhere in the range

        target[count - 4]:target[count - 1], leaving the target string

        unconditionally null terminated in all cases.



        Please note that if the length of source is shorter than count, no

        truncation will be applied, and the target string will be a one to one

        copy of source.



    PARAMETERS

        target - Pointer to the target memory where the content is to be copied.

        source - UTF-8 string to be copied.

        count - Maximum number of bytes to be written to target.



    RETURNS

        Returns target



*******************************************************************************/

u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count);



/*******************************************************************************



    NAME
@@ -139,8 +86,6 @@ u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count); 
*******************************************************************************/

u8 *CsrUtf8StrDup(const u8 *source);



u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4);



/*

 * UCS2

 *

drivers/staging/csr/csr_utf16.c

+0 −60
Original line number Diff line number Diff line
@@ -1064,67 +1064,7 @@ u8 *CsrUtf8StrTruncate(u8 *target, size_t count) 
    return target;

}



u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count)

{

    return (u8 *) CsrStrNCpy((char *) target, (const char *) source, count);

}



u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count)

{

    CsrStrNCpy((char *) target, (const char *) source, count);

    if (target[count - 1] != '\0')

    {

        CsrUtf8StrTruncate(target, count - 1);

    }

    return target;

}



u8 *CsrUtf8StrDup(const u8 *source)

{

    return (u8 *) CsrStrDup((const char *) source);

}
 


u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4)

{

    u8 *outputText;

    u32 textLen, textLen1, textLen2, textLen3, textLen4;



    textLen1 = CsrUtf8StringLengthInBytes(inputText1);

    textLen2 = CsrUtf8StringLengthInBytes(inputText2);

    textLen3 = CsrUtf8StringLengthInBytes(inputText3);

    textLen4 = CsrUtf8StringLengthInBytes(inputText4);



    textLen = textLen1 + textLen2 + textLen3 + textLen4;



    if (textLen == 0) /*stop here is all lengths are 0*/

    {

        return NULL;

    }



    outputText = (u8 *) CsrPmemAlloc((textLen + 1) * sizeof(u8)); /* add space for 0-termination*/





    if (inputText1 != NULL)

    {

        CsrUtf8StrNCpy(outputText, inputText1, textLen1);

    }



    if (inputText2 != NULL)

    {

        CsrUtf8StrNCpy(&(outputText[textLen1]), inputText2, textLen2);

    }



    if (inputText3 != NULL)

    {

        CsrUtf8StrNCpy(&(outputText[textLen1 + textLen2]), inputText3, textLen3);

    }



    if (inputText4 != NULL)

    {

        CsrUtf8StrNCpy(&(outputText[textLen1 + textLen2 + textLen3]), inputText4, textLen4);

    }



    outputText[textLen] = '\0';



    return outputText;

}

drivers/staging/csr/csr_util.c

+0 −5
Original line number Diff line number Diff line
@@ -45,11 +45,6 @@ EXPORT_SYMBOL_GPL(CsrMemCpy); 
#endif



#ifndef CSR_USE_STDC_LIB

char *CsrStrNCpy(char *dest, const char *src, size_t count)

{

    return strncpy(dest, src, count);

}



size_t CsrStrLen(const char *string)

{

    return strlen(string);

drivers/staging/csr/csr_util.h

+0 −2
Original line number Diff line number Diff line
@@ -28,14 +28,12 @@ void CsrUInt16ToHex(u16 number, char *str); 
/*------------------------------------------------------------------*/

#ifdef CSR_USE_STDC_LIB

#define CsrMemCpy memcpy

#define CsrStrNCpy strncpy

#define CsrStrCmp(s1, s2) ((s32) strcmp((s1), (s2)))

#define CsrStrNCmp(s1, s2, n) ((s32) strncmp((s1), (s2), (n)))

#define CsrStrChr strchr

#define CsrStrLen strlen

#else /* !CSR_USE_STDC_LIB */

void *CsrMemCpy(void *dest, const void *src, size_t count);

char *CsrStrNCpy(char *dest, const char *src, size_t count);

s32 CsrStrCmp(const char *string1, const char *string2);

s32 CsrStrNCmp(const char *string1, const char *string2, size_t count);

char *CsrStrChr(const char *string, char c);