diff options
author | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2012-07-20 15:17:59 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2012-07-20 15:17:59 -0400 |
commit | f58bfd88be490c0f9e25d980abe1976ceef00647 (patch) | |
tree | 71b0e4908e4d4bb10014afb85a8ea5cda33d6509 /drivers | |
parent | 9d25edfca7db9404d821c4558e06a2bb98981240 (diff) |
staging: csr: remove CsrUtf16String typedef
Use the in-kernel u16 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>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/staging/csr/csr_msgconv.h | 6 | ||||
-rw-r--r-- | drivers/staging/csr/csr_serialize_primitive_types.c | 6 | ||||
-rw-r--r-- | drivers/staging/csr/csr_types.h | 1 | ||||
-rw-r--r-- | drivers/staging/csr/csr_unicode.h | 32 | ||||
-rw-r--r-- | drivers/staging/csr/csr_utf16.c | 94 |
5 files changed, 69 insertions, 70 deletions
diff --git a/drivers/staging/csr/csr_msgconv.h b/drivers/staging/csr/csr_msgconv.h index 0f614bc7db8..a43a4a624ff 100644 --- a/drivers/staging/csr/csr_msgconv.h +++ b/drivers/staging/csr/csr_msgconv.h | |||
@@ -75,7 +75,7 @@ void CsrMsgConvDeinit(void); | |||
75 | 75 | ||
76 | u32 CsrCharStringSerLen(const CsrCharString *str); | 76 | u32 CsrCharStringSerLen(const CsrCharString *str); |
77 | u32 CsrUtf8StringSerLen(const CsrUtf8String *str); | 77 | u32 CsrUtf8StringSerLen(const CsrUtf8String *str); |
78 | u32 CsrUtf16StringSerLen(const CsrUtf16String *str); | 78 | u32 CsrUtf16StringSerLen(const u16 *str); |
79 | 79 | ||
80 | /* Prototypes for primitive type serializers */ | 80 | /* Prototypes for primitive type serializers */ |
81 | void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value); | 81 | void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value); |
@@ -84,7 +84,7 @@ void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value); | |||
84 | void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length); | 84 | void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length); |
85 | void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value); | 85 | void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value); |
86 | void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value); | 86 | void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value); |
87 | void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value); | 87 | void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value); |
88 | void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr); | 88 | void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr); |
89 | void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value); | 89 | void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value); |
90 | 90 | ||
@@ -94,7 +94,7 @@ void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset); | |||
94 | void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length); | 94 | void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length); |
95 | void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset); | 95 | void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset); |
96 | void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset); | 96 | void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset); |
97 | void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset); | 97 | void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset); |
98 | void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset); | 98 | void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset); |
99 | void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset); | 99 | void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset); |
100 | 100 | ||
diff --git a/drivers/staging/csr/csr_serialize_primitive_types.c b/drivers/staging/csr/csr_serialize_primitive_types.c index a96dcb7343b..f0b9e843cfb 100644 --- a/drivers/staging/csr/csr_serialize_primitive_types.c +++ b/drivers/staging/csr/csr_serialize_primitive_types.c | |||
@@ -61,7 +61,7 @@ void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset) | |||
61 | *offset += CsrStrLen((CsrCharString *) *value) + 1; | 61 | *offset += CsrStrLen((CsrCharString *) *value) + 1; |
62 | } | 62 | } |
63 | 63 | ||
64 | void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset) | 64 | void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset) |
65 | { | 65 | { |
66 | u32 length, i; | 66 | u32 length, i; |
67 | 67 | ||
@@ -139,7 +139,7 @@ void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value) | |||
139 | CsrCharStringSer(buffer, offset, (CsrCharString *) value); | 139 | CsrCharStringSer(buffer, offset, (CsrCharString *) value); |
140 | } | 140 | } |
141 | 141 | ||
142 | void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value) | 142 | void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value) |
143 | { | 143 | { |
144 | if (value) | 144 | if (value) |
145 | { | 145 | { |
@@ -197,7 +197,7 @@ u32 CsrUtf8StringSerLen(const CsrUtf8String *str) | |||
197 | } | 197 | } |
198 | } | 198 | } |
199 | 199 | ||
200 | u32 CsrUtf16StringSerLen(const CsrUtf16String *str) | 200 | u32 CsrUtf16StringSerLen(const u16 *str) |
201 | { | 201 | { |
202 | if (str) | 202 | if (str) |
203 | { | 203 | { |
diff --git a/drivers/staging/csr/csr_types.h b/drivers/staging/csr/csr_types.h index 659343b19d8..054e5c92c25 100644 --- a/drivers/staging/csr/csr_types.h +++ b/drivers/staging/csr/csr_types.h | |||
@@ -38,7 +38,6 @@ typedef u8 CsrBool; | |||
38 | /* String types */ | 38 | /* String types */ |
39 | typedef char CsrCharString; | 39 | typedef char CsrCharString; |
40 | typedef u8 CsrUtf8String; | 40 | typedef u8 CsrUtf8String; |
41 | typedef u16 CsrUtf16String; /* 16-bit UTF16 strings */ | ||
42 | 41 | ||
43 | /* | 42 | /* |
44 | * 64-bit integers | 43 | * 64-bit integers |
diff --git a/drivers/staging/csr/csr_unicode.h b/drivers/staging/csr/csr_unicode.h index 47ade653860..6d2fc6368e6 100644 --- a/drivers/staging/csr/csr_unicode.h +++ b/drivers/staging/csr/csr_unicode.h | |||
@@ -16,27 +16,27 @@ | |||
16 | extern "C" { | 16 | extern "C" { |
17 | #endif | 17 | #endif |
18 | 18 | ||
19 | CsrUtf16String *CsrUint32ToUtf16String(u32 number); | 19 | u16 *CsrUint32ToUtf16String(u32 number); |
20 | 20 | ||
21 | u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString); | 21 | u32 CsrUtf16StringToUint32(const u16 *unicodeString); |
22 | u32 CsrUtf16StrLen(const CsrUtf16String *unicodeString); | 22 | u32 CsrUtf16StrLen(const u16 *unicodeString); |
23 | 23 | ||
24 | CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source); | 24 | CsrUtf8String *CsrUtf16String2Utf8(const u16 *source); |
25 | 25 | ||
26 | CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String); | 26 | u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String); |
27 | 27 | ||
28 | CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source); | 28 | u16 *CsrUtf16StrCpy(u16 *target, const u16 *source); |
29 | CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source); | 29 | u16 *CsrUtf16StringDuplicate(const u16 *source); |
30 | 30 | ||
31 | u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2); | 31 | u16 CsrUtf16StrICmp(const u16 *string1, const u16 *string2); |
32 | u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, u32 count); | 32 | u16 CsrUtf16StrNICmp(const u16 *string1, const u16 *string2, u32 count); |
33 | 33 | ||
34 | CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, u32 count); | 34 | u16 *CsrUtf16MemCpy(u16 *dest, const u16 *src, u32 count); |
35 | CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2, | 35 | u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2, |
36 | const CsrUtf16String *inputText3, const CsrUtf16String *inputText4); | 36 | const u16 *inputText3, const u16 *inputText4); |
37 | 37 | ||
38 | CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str); | 38 | u16 *CsrUtf16String2XML(u16 *str); |
39 | CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str); | 39 | u16 *CsrXML2Utf16String(u16 *str); |
40 | 40 | ||
41 | s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2); | 41 | s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2); |
42 | s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count); | 42 | s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count); |
@@ -180,8 +180,8 @@ CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str); | |||
180 | u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String); | 180 | u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String); |
181 | CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String); | 181 | CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String); |
182 | 182 | ||
183 | u8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source); | 183 | u8 *CsrUtf16String2Ucs2ByteString(const u16 *source); |
184 | CsrUtf16String *CsrUcs2ByteString2Utf16String(const u8 *source); | 184 | u16 *CsrUcs2ByteString2Utf16String(const u8 *source); |
185 | 185 | ||
186 | #ifdef __cplusplus | 186 | #ifdef __cplusplus |
187 | } | 187 | } |
diff --git a/drivers/staging/csr/csr_utf16.c b/drivers/staging/csr/csr_utf16.c index 504825045aa..b33fa0bd2ce 100644 --- a/drivers/staging/csr/csr_utf16.c +++ b/drivers/staging/csr/csr_utf16.c | |||
@@ -73,10 +73,10 @@ static const u32 offsetsFromUtf8[4] = | |||
73 | * Output: A string of UTF-16 characters. | 73 | * Output: A string of UTF-16 characters. |
74 | * | 74 | * |
75 | *********************************************************************************/ | 75 | *********************************************************************************/ |
76 | CsrUtf16String *CsrUint32ToUtf16String(u32 number) | 76 | u16 *CsrUint32ToUtf16String(u32 number) |
77 | { | 77 | { |
78 | u16 count, noOfDigits; | 78 | u16 count, noOfDigits; |
79 | CsrUtf16String *output; | 79 | u16 *output; |
80 | u32 tempNumber; | 80 | u32 tempNumber; |
81 | 81 | ||
82 | /* calculate the number of digits in the output */ | 82 | /* calculate the number of digits in the output */ |
@@ -88,12 +88,12 @@ CsrUtf16String *CsrUint32ToUtf16String(u32 number) | |||
88 | noOfDigits++; | 88 | noOfDigits++; |
89 | } | 89 | } |
90 | 90 | ||
91 | output = (CsrUtf16String *) CsrPmemAlloc(sizeof(CsrUtf16String) * (noOfDigits + 1)); /*add space for 0-termination*/ | 91 | output = (u16 *) CsrPmemAlloc(sizeof(u16) * (noOfDigits + 1)); /*add space for 0-termination*/ |
92 | 92 | ||
93 | tempNumber = number; | 93 | tempNumber = number; |
94 | for (count = noOfDigits; count > 0; count--) | 94 | for (count = noOfDigits; count > 0; count--) |
95 | { | 95 | { |
96 | output[count - 1] = (CsrUtf16String) ((tempNumber % 10) + '0'); | 96 | output[count - 1] = (u16) ((tempNumber % 10) + '0'); |
97 | tempNumber = tempNumber / 10; | 97 | tempNumber = tempNumber / 10; |
98 | } | 98 | } |
99 | output[noOfDigits] = '\0'; | 99 | output[noOfDigits] = '\0'; |
@@ -113,7 +113,7 @@ CsrUtf16String *CsrUint32ToUtf16String(u32 number) | |||
113 | * Output: 32 bit number. | 113 | * Output: 32 bit number. |
114 | * | 114 | * |
115 | *********************************************************************************/ | 115 | *********************************************************************************/ |
116 | u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString) | 116 | u32 CsrUtf16StringToUint32(const u16 *unicodeString) |
117 | { | 117 | { |
118 | u16 numLen, count; | 118 | u16 numLen, count; |
119 | u32 newNumber = 0; | 119 | u32 newNumber = 0; |
@@ -127,7 +127,7 @@ u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString) | |||
127 | 127 | ||
128 | for (count = 0; count < numLen; count++) | 128 | for (count = 0; count < numLen; count++) |
129 | { | 129 | { |
130 | CsrUtf16String input = unicodeString[count]; | 130 | u16 input = unicodeString[count]; |
131 | if ((input < 0x30) || (input > 0x39) || ((newNumber == 0x19999999) && (input > 0x35)) || (newNumber > 0x19999999)) /* chars are present or number is too large now causing number to get to large when *10 */ | 131 | if ((input < 0x30) || (input > 0x39) || ((newNumber == 0x19999999) && (input > 0x35)) || (newNumber > 0x19999999)) /* chars are present or number is too large now causing number to get to large when *10 */ |
132 | { | 132 | { |
133 | return 0; | 133 | return 0; |
@@ -150,9 +150,9 @@ u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString) | |||
150 | * Output: A pointer to an unicoded string. | 150 | * Output: A pointer to an unicoded string. |
151 | * | 151 | * |
152 | *********************************************************************************/ | 152 | *********************************************************************************/ |
153 | CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, u32 count) | 153 | u16 *CsrUtf16MemCpy(u16 *dest, const u16 *src, u32 count) |
154 | { | 154 | { |
155 | return CsrMemCpy((u8 *) dest, (u8 *) src, count * sizeof(CsrUtf16String)); | 155 | return CsrMemCpy((u8 *) dest, (u8 *) src, count * sizeof(u16)); |
156 | } | 156 | } |
157 | 157 | ||
158 | /******************************************************************************** | 158 | /******************************************************************************** |
@@ -167,10 +167,10 @@ CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, | |||
167 | * Output: A new unicoded string (UTF-16) containing the combined strings. | 167 | * Output: A new unicoded string (UTF-16) containing the combined strings. |
168 | * | 168 | * |
169 | *********************************************************************************/ | 169 | *********************************************************************************/ |
170 | CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2, | 170 | u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2, |
171 | const CsrUtf16String *inputText3, const CsrUtf16String *inputText4) | 171 | const u16 *inputText3, const u16 *inputText4) |
172 | { | 172 | { |
173 | CsrUtf16String *outputText; | 173 | u16 *outputText; |
174 | u32 textLen, textLen1, textLen2, textLen3, textLen4; | 174 | u32 textLen, textLen1, textLen2, textLen3, textLen4; |
175 | 175 | ||
176 | textLen1 = CsrUtf16StrLen(inputText1); | 176 | textLen1 = CsrUtf16StrLen(inputText1); |
@@ -185,7 +185,7 @@ CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const | |||
185 | return NULL; | 185 | return NULL; |
186 | } | 186 | } |
187 | 187 | ||
188 | outputText = (CsrUtf16String *) CsrPmemAlloc((textLen + 1) * sizeof(CsrUtf16String)); /* add space for 0-termination*/ | 188 | outputText = (u16 *) CsrPmemAlloc((textLen + 1) * sizeof(u16)); /* add space for 0-termination*/ |
189 | 189 | ||
190 | 190 | ||
191 | if (inputText1 != NULL) | 191 | if (inputText1 != NULL) |
@@ -225,7 +225,7 @@ CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const | |||
225 | * Output: The number of 16 bit elements in the string. | 225 | * Output: The number of 16 bit elements in the string. |
226 | * | 226 | * |
227 | *********************************************************************************/ | 227 | *********************************************************************************/ |
228 | u32 CsrUtf16StrLen(const CsrUtf16String *unicodeString) | 228 | u32 CsrUtf16StrLen(const u16 *unicodeString) |
229 | { | 229 | { |
230 | u32 length; | 230 | u32 length; |
231 | 231 | ||
@@ -253,7 +253,7 @@ u32 CsrUtf16StrLen(const CsrUtf16String *unicodeString) | |||
253 | * Output: 0-terminated string of byte oriented UTF8 coded characters. | 253 | * Output: 0-terminated string of byte oriented UTF8 coded characters. |
254 | * | 254 | * |
255 | *********************************************************************************/ | 255 | *********************************************************************************/ |
256 | CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source) | 256 | CsrUtf8String *CsrUtf16String2Utf8(const u16 *source) |
257 | { | 257 | { |
258 | CsrUtf8String *dest, *destStart = NULL; | 258 | CsrUtf8String *dest, *destStart = NULL; |
259 | u32 i; | 259 | u32 i; |
@@ -562,12 +562,12 @@ static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length) | |||
562 | * Output: 0-terminated string of UTF-16 characters. | 562 | * Output: 0-terminated string of UTF-16 characters. |
563 | * | 563 | * |
564 | *********************************************************************************/ | 564 | *********************************************************************************/ |
565 | CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String) | 565 | u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String) |
566 | { | 566 | { |
567 | CsrSize i, length = 0; | 567 | CsrSize i, length = 0; |
568 | CsrSize sourceLength; | 568 | CsrSize sourceLength; |
569 | CsrUtf16String *dest = NULL; | 569 | u16 *dest = NULL; |
570 | CsrUtf16String *destStart = NULL; | 570 | u16 *destStart = NULL; |
571 | s8 extraBytes2Read; | 571 | s8 extraBytes2Read; |
572 | 572 | ||
573 | if (!utf8String) | 573 | if (!utf8String) |
@@ -610,7 +610,7 @@ CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String) | |||
610 | } | 610 | } |
611 | 611 | ||
612 | /* Create space for the null terminated character */ | 612 | /* Create space for the null terminated character */ |
613 | dest = (CsrUtf16String *) CsrPmemAlloc((1 + length) * sizeof(CsrUtf16String)); | 613 | dest = (u16 *) CsrPmemAlloc((1 + length) * sizeof(u16)); |
614 | destStart = dest; | 614 | destStart = dest; |
615 | 615 | ||
616 | for (i = 0; i < sourceLength; i++) | 616 | for (i = 0; i < sourceLength; i++) |
@@ -703,11 +703,11 @@ CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String) | |||
703 | * Output: 0-terminated UTF-16 string. | 703 | * Output: 0-terminated UTF-16 string. |
704 | * | 704 | * |
705 | *********************************************************************************/ | 705 | *********************************************************************************/ |
706 | CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source) | 706 | u16 *CsrUtf16StrCpy(u16 *target, const u16 *source) |
707 | { | 707 | { |
708 | if (source) /* if source is not NULL*/ | 708 | if (source) /* if source is not NULL*/ |
709 | { | 709 | { |
710 | CsrMemCpy(target, source, (CsrUtf16StrLen(source) + 1) * sizeof(CsrUtf16String)); | 710 | CsrMemCpy(target, source, (CsrUtf16StrLen(source) + 1) * sizeof(u16)); |
711 | return target; | 711 | return target; |
712 | } | 712 | } |
713 | else | 713 | else |
@@ -728,15 +728,15 @@ CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *sou | |||
728 | * Output: Allocated variable0-terminated UTF-16 string. | 728 | * Output: Allocated variable0-terminated UTF-16 string. |
729 | * | 729 | * |
730 | *********************************************************************************/ | 730 | *********************************************************************************/ |
731 | CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source) | 731 | u16 *CsrUtf16StringDuplicate(const u16 *source) |
732 | { | 732 | { |
733 | CsrUtf16String *target = NULL; | 733 | u16 *target = NULL; |
734 | u32 length; | 734 | u32 length; |
735 | 735 | ||
736 | if (source) /* if source is not NULL*/ | 736 | if (source) /* if source is not NULL*/ |
737 | { | 737 | { |
738 | length = (CsrUtf16StrLen(source) + 1) * sizeof(CsrUtf16String); | 738 | length = (CsrUtf16StrLen(source) + 1) * sizeof(u16); |
739 | target = (CsrUtf16String *) CsrPmemAlloc(length); | 739 | target = (u16 *) CsrPmemAlloc(length); |
740 | CsrMemCpy(target, source, length); | 740 | CsrMemCpy(target, source, length); |
741 | } | 741 | } |
742 | return target; | 742 | return target; |
@@ -753,7 +753,7 @@ CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source) | |||
753 | * Output: 0: if the strings are identical. | 753 | * Output: 0: if the strings are identical. |
754 | * | 754 | * |
755 | *********************************************************************************/ | 755 | *********************************************************************************/ |
756 | u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2) | 756 | u16 CsrUtf16StrICmp(const u16 *string1, const u16 *string2) |
757 | { | 757 | { |
758 | while (*string1 || *string2) | 758 | while (*string1 || *string2) |
759 | { | 759 | { |
@@ -781,7 +781,7 @@ u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2 | |||
781 | * Output: 0: if the strings are identical. | 781 | * Output: 0: if the strings are identical. |
782 | * | 782 | * |
783 | *********************************************************************************/ | 783 | *********************************************************************************/ |
784 | u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, u32 count) | 784 | u16 CsrUtf16StrNICmp(const u16 *string1, const u16 *string2, u32 count) |
785 | { | 785 | { |
786 | while ((*string1 || *string2) && count--) | 786 | while ((*string1 || *string2) && count--) |
787 | { | 787 | { |
@@ -809,11 +809,11 @@ u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string | |||
809 | * Output: A new unicoded string (UTF-16) containing the converted output. | 809 | * Output: A new unicoded string (UTF-16) containing the converted output. |
810 | * | 810 | * |
811 | *********************************************************************************/ | 811 | *********************************************************************************/ |
812 | CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str) | 812 | u16 *CsrUtf16String2XML(u16 *str) |
813 | { | 813 | { |
814 | CsrUtf16String *scanString; | 814 | u16 *scanString; |
815 | CsrUtf16String *outputString = NULL; | 815 | u16 *outputString = NULL; |
816 | CsrUtf16String *resultString = str; | 816 | u16 *resultString = str; |
817 | u32 stringLength = 0; | 817 | u32 stringLength = 0; |
818 | CsrBool encodeChars = FALSE; | 818 | CsrBool encodeChars = FALSE; |
819 | 819 | ||
@@ -844,7 +844,7 @@ CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str) | |||
844 | 844 | ||
845 | if (encodeChars) | 845 | if (encodeChars) |
846 | { | 846 | { |
847 | resultString = outputString = CsrPmemAlloc(stringLength * sizeof(CsrUtf16String)); | 847 | resultString = outputString = CsrPmemAlloc(stringLength * sizeof(u16)); |
848 | 848 | ||
849 | scanString = str; | 849 | scanString = str; |
850 | 850 | ||
@@ -902,11 +902,11 @@ CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str) | |||
902 | * Output: A new unicoded pointer containing the decoded output. | 902 | * Output: A new unicoded pointer containing the decoded output. |
903 | * | 903 | * |
904 | *********************************************************************************/ | 904 | *********************************************************************************/ |
905 | CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str) | 905 | u16 *CsrXML2Utf16String(u16 *str) |
906 | { | 906 | { |
907 | CsrUtf16String *scanString; | 907 | u16 *scanString; |
908 | CsrUtf16String *outputString = NULL; | 908 | u16 *outputString = NULL; |
909 | CsrUtf16String *resultString = str; | 909 | u16 *resultString = str; |
910 | u32 stringLength = 0; | 910 | u32 stringLength = 0; |
911 | CsrBool encodeChars = FALSE; | 911 | CsrBool encodeChars = FALSE; |
912 | 912 | ||
@@ -915,31 +915,31 @@ CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str) | |||
915 | { | 915 | { |
916 | while (*scanString) | 916 | while (*scanString) |
917 | { | 917 | { |
918 | if (*scanString == (CsrUtf16String) L'&') | 918 | if (*scanString == (u16) L'&') |
919 | { | 919 | { |
920 | scanString++; | 920 | scanString++; |
921 | 921 | ||
922 | if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"AMP;", 4)) | 922 | if (!CsrUtf16StrNICmp(scanString, (u16 *) L"AMP;", 4)) |
923 | { | 923 | { |
924 | scanString += 3; | 924 | scanString += 3; |
925 | encodeChars = TRUE; | 925 | encodeChars = TRUE; |
926 | } | 926 | } |
927 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"LT;", 3)) | 927 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"LT;", 3)) |
928 | { | 928 | { |
929 | scanString += 2; | 929 | scanString += 2; |
930 | encodeChars = TRUE; | 930 | encodeChars = TRUE; |
931 | } | 931 | } |
932 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"GT;", 3)) | 932 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"GT;", 3)) |
933 | { | 933 | { |
934 | scanString += 2; | 934 | scanString += 2; |
935 | encodeChars = TRUE; | 935 | encodeChars = TRUE; |
936 | } | 936 | } |
937 | if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"APOS;", 5)) | 937 | if (!CsrUtf16StrNICmp(scanString, (u16 *) L"APOS;", 5)) |
938 | { | 938 | { |
939 | scanString += 4; | 939 | scanString += 4; |
940 | encodeChars = TRUE; | 940 | encodeChars = TRUE; |
941 | } | 941 | } |
942 | if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"QUOT;", 5)) | 942 | if (!CsrUtf16StrNICmp(scanString, (u16 *) L"QUOT;", 5)) |
943 | { | 943 | { |
944 | scanString += 4; | 944 | scanString += 4; |
945 | encodeChars = TRUE; | 945 | encodeChars = TRUE; |
@@ -958,7 +958,7 @@ CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str) | |||
958 | 958 | ||
959 | if (encodeChars) | 959 | if (encodeChars) |
960 | { | 960 | { |
961 | resultString = outputString = CsrPmemAlloc(stringLength * sizeof(CsrUtf16String)); | 961 | resultString = outputString = CsrPmemAlloc(stringLength * sizeof(u16)); |
962 | 962 | ||
963 | scanString = str; | 963 | scanString = str; |
964 | 964 | ||
@@ -968,27 +968,27 @@ CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str) | |||
968 | { | 968 | { |
969 | scanString++; | 969 | scanString++; |
970 | 970 | ||
971 | if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"AMP;", 4)) | 971 | if (!CsrUtf16StrNICmp(scanString, (u16 *) L"AMP;", 4)) |
972 | { | 972 | { |
973 | *outputString++ = L'&'; | 973 | *outputString++ = L'&'; |
974 | scanString += 3; | 974 | scanString += 3; |
975 | } | 975 | } |
976 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"LT;", 3)) | 976 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"LT;", 3)) |
977 | { | 977 | { |
978 | *outputString++ = L'<'; | 978 | *outputString++ = L'<'; |
979 | scanString += 2; | 979 | scanString += 2; |
980 | } | 980 | } |
981 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"GT;", 3)) | 981 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"GT;", 3)) |
982 | { | 982 | { |
983 | *outputString++ = L'>'; | 983 | *outputString++ = L'>'; |
984 | scanString += 2; | 984 | scanString += 2; |
985 | } | 985 | } |
986 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"APOS;", 5)) | 986 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"APOS;", 5)) |
987 | { | 987 | { |
988 | *outputString++ = L'\''; | 988 | *outputString++ = L'\''; |
989 | scanString += 4; | 989 | scanString += 4; |
990 | } | 990 | } |
991 | else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"QUOT;", 5)) | 991 | else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"QUOT;", 5)) |
992 | { | 992 | { |
993 | *outputString++ = L'\"'; | 993 | *outputString++ = L'\"'; |
994 | scanString += 4; | 994 | scanString += 4; |