]> git.proxmox.com Git - mirror_edk2.git/blob - MdePkg/Library/BaseLib/String.c
projects / mirror_edk2.git / blob
? search:


80223c6732ebedcb0df7fe0747d2d1678f90b244
[mirror_edk2.git] / MdePkg / Library / BaseLib / String.c
1 /** @file
2 Unicode string primatives.
3
4 Copyright (c) 2006, Intel Corporation<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 Module Name: String.c
14
15 **/
16
17 /**
18 Copies one Null-terminated Unicode string to another Null-terminated Unicode
19 string and returns the new Unicode string.
20
21 This function copies the contents of the Unicode string Source to the Unicode
22 string Destination, and returns Destination. If Source and Destination
23 overlap, then the results are undefined.
24
25 If Destination is NULL, then ASSERT().
26 If Source is NULL, then ASSERT().
27 If Source and Destination overlap, then ASSERT().
28 If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
29 PcdMaximumUnicodeStringLength Unicode characters not including the
30 Null-terminator, then ASSERT().
31
32 @param Destination Pointer to a Null-terminated Unicode string.
33 @param Source Pointer to a Null-terminated Unicode string.
34
35 @return Destiantion
36
37 **/
38 CHAR16 *
39 EFIAPI
40 StrCpy (
41 OUT CHAR16 *Destination,
42 IN CONST CHAR16 *Source
43 )
44 {
45 CHAR16 *ReturnValue;
46
47 //
48 // Destination cannot be NULL
49 //
50 ASSERT (Destination != NULL);
51
52 //
53 // Destination and source cannot overlap
54 //
55 ASSERT ((UINTN)(Destination - Source) > StrLen (Source));
56 ASSERT ((UINTN)(Source - Destination) > StrLen (Source));
57
58 ReturnValue = Destination;
59 while (*Source) {
60 *(Destination++) = *(Source++);
61 }
62 *Destination = 0;
63 return ReturnValue;
64 }
65
66 /**
67 Copies one Null-terminated Unicode string with a maximum length to another
68 Null-terminated Unicode string with a maximum length and returns the new
69 Unicode string.
70
71 This function copies the contents of the Unicode string Source to the Unicode
72 string Destination, and returns Destination. At most, Length Unicode
73 characters are copied from Source to Destination. If Length is 0, then
74 Destination is returned unmodified. If Length is greater that the number of
75 Unicode characters in Source, then Destination is padded with Null Unicode
76 characters. If Source and Destination overlap, then the results are
77 undefined.
78
79 If Destination is NULL, then ASSERT().
80 If Source is NULL, then ASSERT().
81 If Source and Destination overlap, then ASSERT().
82 If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
83 PcdMaximumUnicodeStringLength Unicode characters not including the
84 Null-terminator, then ASSERT().
85
86 @param Destination Pointer to a Null-terminated Unicode string.
87 @param Source Pointer to a Null-terminated Unicode string.
88 @param Length Maximum number of Unicode characters to copy.
89
90 @return Destination
91
92 **/
93 CHAR16 *
94 EFIAPI
95 StrnCpy (
96 OUT CHAR16 *Destination,
97 IN CONST CHAR16 *Source,
98 IN UINTN Length
99 )
100 {
101 CHAR16 *ReturnValue;
102
103 if (Length == 0) {
104 return Destination;
105 }
106
107 //
108 // Destination cannot be NULL if Length is not zero
109 //
110 ASSERT (Destination != NULL);
111
112 //
113 // Destination and source cannot overlap
114 // Q: Does Source have to be NULL-terminated?
115 //
116 ASSERT ((UINTN)(Destination - Source) > StrLen (Source));
117 ASSERT ((UINTN)(Source - Destination) >= Length);
118
119 ReturnValue = Destination;
120
121 while ((*Source != L'\0') && (Length > 0)) {
122 *(Destination++) = *(Source++);
123 Length--;
124 }
125
126 ZeroMem (Destination, Length * sizeof (*Destination));
127 return ReturnValue;
128 }
129
130 /**
131 Returns the length of a Null-terminated Unicode string.
132
133 This function returns the number of Unicode characters in the Null-terminated
134 Unicode string specified by String.
135
136 If String is NULL, then ASSERT().
137 If PcdMaximumUnicodeStringLength is not zero, and String contains more than
138 PcdMaximumUnicodeStringLength Unicode characters not including the
139 Null-terminator, then ASSERT().
140
141 @param String Pointer to a Null-terminated Unicode string.
142
143 @return The length of String.
144
145 **/
146 UINTN
147 EFIAPI
148 StrLen (
149 IN CONST CHAR16 *String
150 )
151 {
152 UINTN Length;
153
154 ASSERT (String != NULL);
155
156 for (Length = 0; *String != L'\0'; String++, Length++) {
157 //
158 // If PcdMaximumUnicodeStringLength is not zero,
159 // length should not more than PcdMaximumUnicodeStringLength
160 //
161 if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
162 ASSERT (Length < PcdGet32 (PcdMaximumUnicodeStringLength));
163 }
164 }
165 return Length;
166 }
167
168 /**
169 Returns the size of a Null-terminated Unicode string in bytes, including the
170 Null terminator.
171
172 This function returns the size, in bytes, of the Null-terminated Unicode
173 string specified by String.
174
175 If String is NULL, then ASSERT().
176 If PcdMaximumUnicodeStringLength is not zero, and String contains more than
177 PcdMaximumUnicodeStringLength Unicode characters not including the
178 Null-terminator, then ASSERT().
179
180 @param String Pointer to a Null-terminated Unicode string.
181
182 @return The size of String.
183
184 **/
185 UINTN
186 EFIAPI
187 StrSize (
188 IN CONST CHAR16 *String
189 )
190 {
191 return (StrLen (String) + 1) * sizeof (*String);
192 }
193
194 /**
195 Compares two Null-terminated Unicode strings, and returns the difference
196 between the first mismatched Unicode characters.
197
198 This function compares the Null-terminated Unicode string FirstString to the
199 Null-terminated Unicode string SecondString. If FirstString is identical to
200 SecondString, then 0 is returned. Otherwise, the value returned is the first
201 mismatched Unicode character in SecondString subtracted from the first
202 mismatched Unicode character in FirstString.
203
204 If FirstString is NULL, then ASSERT().
205 If SecondString is NULL, then ASSERT().
206 If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more
207 than PcdMaximumUnicodeStringLength Unicode characters not including the
208 Null-terminator, then ASSERT().
209 If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more
210 than PcdMaximumUnicodeStringLength Unicode characters not including the
211 Null-terminator, then ASSERT().
212
213 @param FirstString Pointer to a Null-terminated Unicode string.
214 @param SecondString Pointer to a Null-terminated Unicode string.
215
216 @retval 0 FirstString is identical to SecondString.
217 @retval !=0 FirstString is not identical to SecondString.
218
219 **/
220 INTN
221 EFIAPI
222 StrCmp (
223 IN CONST CHAR16 *FirstString,
224 IN CONST CHAR16 *SecondString
225 )
226 {
227 //
228 // ASSERT both strings are less long than PcdMaximumUnicodeStringLength
229 //
230 ASSERT (StrSize (FirstString) != 0);
231 ASSERT (StrSize (SecondString) != 0);
232
233 while ((*FirstString != L'\0') && (*FirstString == *SecondString)) {
234 FirstString++;
235 SecondString++;
236 }
237 return *FirstString - *SecondString;
238 }
239
240 /**
241 Compares two Null-terminated Unicode strings with maximum lengths, and
242 returns the difference between the first mismatched Unicode characters.
243
244 This function compares the Null-terminated Unicode string FirstString to the
245 Null-terminated Unicode string SecondString. At most, Length Unicode
246 characters will be compared. If Length is 0, then 0 is returned. If
247 FirstString is identical to SecondString, then 0 is returned. Otherwise, the
248 value returned is the first mismatched Unicode character in SecondString
249 subtracted from the first mismatched Unicode character in FirstString.
250
251 If FirstString is NULL, then ASSERT().
252 If SecondString is NULL, then ASSERT().
253 If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more
254 than PcdMaximumUnicodeStringLength Unicode characters not including the
255 Null-terminator, then ASSERT().
256 If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more
257 than PcdMaximumUnicodeStringLength Unicode characters not including the
258 Null-terminator, then ASSERT().
259
260 @param FirstString Pointer to a Null-terminated Unicode string.
261 @param SecondString Pointer to a Null-terminated Unicode string.
262 @param Length Maximum number of Unicode characters to compare.
263
264 @retval 0 FirstString is identical to SecondString.
265 @retval !=0 FirstString is not identical to SecondString.
266
267 **/
268 INTN
269 EFIAPI
270 StrnCmp (
271 IN CONST CHAR16 *FirstString,
272 IN CONST CHAR16 *SecondString,
273 IN UINTN Length
274 )
275 {
276 if (Length == 0) {
277 return 0;
278 }
279
280 //
281 // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.
282 // Length tests are performed inside StrLen().
283 //
284 ASSERT (StrSize (FirstString) != 0);
285 ASSERT (StrSize (SecondString) != 0);
286
287 while ((*FirstString != L'\0') &&
288 (*FirstString == *SecondString) &&
289 (Length > 1)) {
290 FirstString++;
291 SecondString++;
292 Length--;
293 }
294
295 return *FirstString - *SecondString;
296 }
297
298 /**
299 Concatenates one Null-terminated Unicode string to another Null-terminated
300 Unicode string, and returns the concatenated Unicode string.
301
302 This function concatenates two Null-terminated Unicode strings. The contents
303 of Null-terminated Unicode string Source are concatenated to the end of
304 Null-terminated Unicode string Destination. The Null-terminated concatenated
305 Unicode String is returned. If Source and Destination overlap, then the
306 results are undefined.
307
308 If Destination is NULL, then ASSERT().
309 If Source is NULL, then ASSERT().
310 If Source and Destination overlap, then ASSERT().
311 If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
312 than PcdMaximumUnicodeStringLength Unicode characters not including the
313 Null-terminator, then ASSERT().
314 If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
315 PcdMaximumUnicodeStringLength Unicode characters not including the
316 Null-terminator, then ASSERT().
317 If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
318 and Source results in a Unicode string with more than
319 PcdMaximumUnicodeStringLength Unicode characters not including the
320 Null-terminator, then ASSERT().
321
322 @param Destination Pointer to a Null-terminated Unicode string.
323 @param Source Pointer to a Null-terminated Unicode string.
324
325 @return Destination
326
327 **/
328 CHAR16 *
329 EFIAPI
330 StrCat (
331 IN OUT CHAR16 *Destination,
332 IN CONST CHAR16 *Source
333 )
334 {
335 StrCpy (Destination + StrLen (Destination), Source);
336
337 //
338 // Size of the resulting string should never be zero.
339 // PcdMaximumUnicodeStringLength is tested inside StrLen().
340 //
341 ASSERT (StrSize (Destination) != 0);
342 return Destination;
343 }
344
345 /**
346 Concatenates one Null-terminated Unicode string with a maximum length to the
347 end of another Null-terminated Unicode string, and returns the concatenated
348 Unicode string.
349
350 This function concatenates two Null-terminated Unicode strings. The contents
351 of Null-terminated Unicode string Source are concatenated to the end of
352 Null-terminated Unicode string Destination, and Destination is returned. At
353 most, Length Unicode characters are concatenated from Source to the end of
354 Destination, and Destination is always Null-terminated. If Length is 0, then
355 Destination is returned unmodified. If Source and Destination overlap, then
356 the results are undefined.
357
358 If Destination is NULL, then ASSERT().
359 If Source is NULL, then ASSERT().
360 If Source and Destination overlap, then ASSERT().
361 If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
362 than PcdMaximumUnicodeStringLength Unicode characters not including the
363 Null-terminator, then ASSERT().
364 If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
365 PcdMaximumUnicodeStringLength Unicode characters not including the
366 Null-terminator, then ASSERT().
367 If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
368 and Source results in a Unicode string with more than
369 PcdMaximumUnicodeStringLength Unicode characters not including the
370 Null-terminator, then ASSERT().
371
372 @param Destination Pointer to a Null-terminated Unicode string.
373 @param Source Pointer to a Null-terminated Unicode string.
374 @param Length Maximum number of Unicode characters to concatenate from
375 Source.
376
377 @return Destination
378
379 **/
380 CHAR16 *
381 EFIAPI
382 StrnCat (
383 IN OUT CHAR16 *Destination,
384 IN CONST CHAR16 *Source,
385 IN UINTN Length
386 )
387 {
388 StrnCpy (Destination + StrLen (Destination), Source, Length);
389
390 //
391 // Size of the resulting string should never be zero.
392 // PcdMaximumUnicodeStringLength is tested inside StrLen().
393 //
394 ASSERT (StrSize (Destination) != 0);
395 return Destination;
396 }
397
398 /**
399 Copies one Null-terminated ASCII string to another Null-terminated ASCII
400 string and returns the new ASCII string.
401
402 This function copies the contents of the ASCII string Source to the ASCII
403 string Destination, and returns Destination. If Source and Destination
404 overlap, then the results are undefined.
405
406 If Destination is NULL, then ASSERT().
407 If Source is NULL, then ASSERT().
408 If Source and Destination overlap, then ASSERT().
409 If PcdMaximumAsciiStringLength is not zero and Source contains more than
410 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
411 then ASSERT().
412
413 @param Destination Pointer to a Null-terminated ASCII string.
414 @param Source Pointer to a Null-terminated ASCII string.
415
416 @return Destination
417
418 **/
419 CHAR8 *
420 EFIAPI
421 AsciiStrCpy (
422 OUT CHAR8 *Destination,
423 IN CONST CHAR8 *Source
424 )
425 {
426 CHAR8 *ReturnValue;
427
428 //
429 // Destination cannot be NULL
430 //
431 ASSERT (Destination != NULL);
432
433 //
434 // Destination and source cannot overlap
435 //
436 ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));
437 ASSERT ((UINTN)(Source - Destination) > AsciiStrLen (Source));
438
439 ReturnValue = Destination;
440 while (*Source) {
441 *(Destination++) = *(Source++);
442 }
443 *Destination = 0;
444 return ReturnValue;
445 }
446
447 /**
448 Copies one Null-terminated ASCII string with a maximum length to another
449 Null-terminated ASCII string with a maximum length and returns the new ASCII
450 string.
451
452 This function copies the contents of the ASCII string Source to the ASCII
453 string Destination, and returns Destination. At most, Length ASCII characters
454 are copied from Source to Destination. If Length is 0, then Destination is
455 returned unmodified. If Length is greater that the number of ASCII characters
456 in Source, then Destination is padded with Null ASCII characters. If Source
457 and Destination overlap, then the results are undefined.
458
459 If Destination is NULL, then ASSERT().
460 If Source is NULL, then ASSERT().
461 If Source and Destination overlap, then ASSERT().
462 If PcdMaximumAsciiStringLength is not zero, and Source contains more than
463 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
464 then ASSERT().
465
466 @param Destination Pointer to a Null-terminated ASCII string.
467 @param Source Pointer to a Null-terminated ASCII string.
468 @param Length Maximum number of ASCII characters to copy.
469
470 @return Destination
471
472 **/
473 CHAR8 *
474 EFIAPI
475 AsciiStrnCpy (
476 OUT CHAR8 *Destination,
477 IN CONST CHAR8 *Source,
478 IN UINTN Length
479 )
480 {
481 CHAR8 *ReturnValue;
482
483 if (Length == 0) {
484 return Destination;
485 }
486
487 //
488 // Destination cannot be NULL
489 //
490 ASSERT (Destination != NULL);
491
492 //
493 // Destination and source cannot overlap
494 //
495 ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));
496 ASSERT ((UINTN)(Source - Destination) >= Length);
497
498 ReturnValue = Destination;
499
500 while (*Source && Length > 0) {
501 *(Destination++) = *(Source++);
502 Length--;
503 }
504
505 ZeroMem (Destination, Length * sizeof (*Destination));
506 return ReturnValue;
507 }
508
509 /**
510 Returns the length of a Null-terminated ASCII string.
511
512 This function returns the number of ASCII characters in the Null-terminated
513 ASCII string specified by String.
514
515 If String is NULL, then ASSERT().
516 If PcdMaximumAsciiStringLength is not zero and String contains more than
517 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
518 then ASSERT().
519
520 @param String Pointer to a Null-terminated ASCII string.
521
522 @return The length of String.
523
524 **/
525 UINTN
526 EFIAPI
527 AsciiStrLen (
528 IN CONST CHAR8 *String
529 )
530 {
531 UINTN Length;
532
533 ASSERT (String != NULL);
534
535 for (Length = 0; *String != '\0'; String++, Length++) {
536 //
537 // If PcdMaximumUnicodeStringLength is not zero,
538 // length should not more than PcdMaximumUnicodeStringLength
539 //
540 if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
541 ASSERT (Length < PcdGet32 (PcdMaximumAsciiStringLength));
542 }
543 }
544 return Length;
545 }
546
547 /**
548 Returns the size of a Null-terminated ASCII string in bytes, including the
549 Null terminator.
550
551 This function returns the size, in bytes, of the Null-terminated ASCII string
552 specified by String.
553
554 If String is NULL, then ASSERT().
555 If PcdMaximumAsciiStringLength is not zero and String contains more than
556 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
557 then ASSERT().
558
559 @param String Pointer to a Null-terminated ASCII string.
560
561 @return The size of String.
562
563 **/
564 UINTN
565 EFIAPI
566 AsciiStrSize (
567 IN CONST CHAR8 *String
568 )
569 {
570 return (AsciiStrLen (String) + 1) * sizeof (*String);
571 }
572
573 /**
574 Compares two Null-terminated ASCII strings, and returns the difference
575 between the first mismatched ASCII characters.
576
577 This function compares the Null-terminated ASCII string FirstString to the
578 Null-terminated ASCII string SecondString. If FirstString is identical to
579 SecondString, then 0 is returned. Otherwise, the value returned is the first
580 mismatched ASCII character in SecondString subtracted from the first
581 mismatched ASCII character in FirstString.
582
583 If FirstString is NULL, then ASSERT().
584 If SecondString is NULL, then ASSERT().
585 If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
586 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
587 then ASSERT().
588 If PcdMaximumAsciiStringLength is not zero and SecondString contains more
589 than PcdMaximumAsciiStringLength ASCII characters not including the
590 Null-terminator, then ASSERT().
591
592 @param FirstString Pointer to a Null-terminated ASCII string.
593 @param SecondString Pointer to a Null-terminated ASCII string.
594
595 @retval 0 FirstString is identical to SecondString.
596 @retval !=0 FirstString is not identical to SecondString.
597
598 **/
599 INTN
600 EFIAPI
601 AsciiStrCmp (
602 IN CONST CHAR8 *FirstString,
603 IN CONST CHAR8 *SecondString
604 )
605 {
606 //
607 // ASSERT both strings are less long than PcdMaximumAsciiStringLength
608 //
609 ASSERT (AsciiStrSize (FirstString));
610 ASSERT (AsciiStrSize (SecondString));
611
612 while ((*FirstString != '\0') && (*FirstString == *SecondString)) {
613 FirstString++;
614 SecondString++;
615 }
616
617 return *FirstString - *SecondString;
618 }
619
620 STATIC
621 CHAR8
622 EFIAPI
623 AsciiToUpper (
624 IN CHAR8 Chr
625 )
626 {
627 return (Chr >= 'a' && Chr <= 'z') ? Chr - ('a' - 'A') : Chr;
628 }
629
630 /**
631 Performs a case insensitive comparison of two Null-terminated ASCII strings,
632 and returns the difference between the first mismatched ASCII characters.
633
634 This function performs a case insensitive comparison of the Null-terminated
635 ASCII string FirstString to the Null-terminated ASCII string SecondString. If
636 FirstString is identical to SecondString, then 0 is returned. Otherwise, the
637 value returned is the first mismatched lower case ASCII character in
638 SecondString subtracted from the first mismatched lower case ASCII character
639 in FirstString.
640
641 If FirstString is NULL, then ASSERT().
642 If SecondString is NULL, then ASSERT().
643 If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
644 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
645 then ASSERT().
646 If PcdMaximumAsciiStringLength is not zero and SecondString contains more
647 than PcdMaximumAsciiStringLength ASCII characters not including the
648 Null-terminator, then ASSERT().
649
650 @param FirstString Pointer to a Null-terminated ASCII string.
651 @param SecondString Pointer to a Null-terminated ASCII string.
652
653 @retval 0 FirstString is identical to SecondString using case insensitive
654 comparisons.
655 @retval !=0 FirstString is not identical to SecondString using case
656 insensitive comparisons.
657
658 **/
659 INTN
660 EFIAPI
661 AsciiStriCmp (
662 IN CONST CHAR8 *FirstString,
663 IN CONST CHAR8 *SecondString
664 )
665 {
666 //
667 // ASSERT both strings are less long than PcdMaximumAsciiStringLength
668 //
669 ASSERT (AsciiStrSize (FirstString));
670 ASSERT (AsciiStrSize (SecondString));
671
672 while ((*FirstString != '\0') &&
673 (AsciiToUpper (*FirstString) == AsciiToUpper (*SecondString))) {
674 FirstString++;
675 SecondString++;
676 }
677
678 return AsciiToUpper (*FirstString) - AsciiToUpper (*SecondString);
679 }
680
681 /**
682 Compares two Null-terminated ASCII strings with maximum lengths, and returns
683 the difference between the first mismatched ASCII characters.
684
685 This function compares the Null-terminated ASCII string FirstString to the
686 Null-terminated ASCII string SecondString. At most, Length ASCII characters
687 will be compared. If Length is 0, then 0 is returned. If FirstString is
688 identical to SecondString, then 0 is returned. Otherwise, the value returned
689 is the first mismatched ASCII character in SecondString subtracted from the
690 first mismatched ASCII character in FirstString.
691
692 If FirstString is NULL, then ASSERT().
693 If SecondString is NULL, then ASSERT().
694 If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
695 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
696 then ASSERT().
697 If PcdMaximumAsciiStringLength is not zero and SecondString contains more than
698 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
699 then ASSERT().
700
701 @param FirstString Pointer to a Null-terminated ASCII string.
702 @param SecondString Pointer to a Null-terminated ASCII string.
703
704 @retval 0 FirstString is identical to SecondString.
705 @retval !=0 FirstString is not identical to SecondString.
706
707 **/
708 INTN
709 EFIAPI
710 AsciiStrnCmp (
711 IN CONST CHAR8 *FirstString,
712 IN CONST CHAR8 *SecondString,
713 IN UINTN Length
714 )
715 {
716 //
717 // ASSERT both strings are less long than PcdMaximumAsciiStringLength
718 //
719 ASSERT (AsciiStrSize (FirstString));
720 ASSERT (AsciiStrSize (SecondString));
721
722 while ((*FirstString != '\0') &&
723 (*FirstString == *SecondString) &&
724 (Length > 1)) {
725 FirstString++;
726 SecondString++;
727 Length--;
728 }
729 return *FirstString - *SecondString;
730 }
731
732 /**
733 Concatenates one Null-terminated ASCII string to another Null-terminated
734 ASCII string, and returns the concatenated ASCII string.
735
736 This function concatenates two Null-terminated ASCII strings. The contents of
737 Null-terminated ASCII string Source are concatenated to the end of Null-
738 terminated ASCII string Destination. The Null-terminated concatenated ASCII
739 String is returned.
740
741 If Destination is NULL, then ASSERT().
742 If Source is NULL, then ASSERT().
743 If PcdMaximumAsciiStringLength is not zero and Destination contains more than
744 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
745 then ASSERT().
746 If PcdMaximumAsciiStringLength is not zero and Source contains more than
747 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
748 then ASSERT().
749 If PcdMaximumAsciiStringLength is not zero and concatenating Destination and
750 Source results in a ASCII string with more than PcdMaximumAsciiStringLength
751 ASCII characters, then ASSERT().
752
753 @param Destination Pointer to a Null-terminated ASCII string.
754 @param Source Pointer to a Null-terminated ASCII string.
755
756 @return Destination
757
758 **/
759 CHAR8 *
760 EFIAPI
761 AsciiStrCat (
762 IN OUT CHAR8 *Destination,
763 IN CONST CHAR8 *Source
764 )
765 {
766 AsciiStrCpy (Destination + AsciiStrLen (Destination), Source);
767
768 //
769 // Size of the resulting string should never be zero.
770 // PcdMaximumUnicodeStringLength is tested inside StrLen().
771 //
772 ASSERT (AsciiStrSize (Destination) != 0);
773 return Destination;
774 }
775
776 /**
777 Concatenates one Null-terminated ASCII string with a maximum length to the
778 end of another Null-terminated ASCII string, and returns the concatenated
779 ASCII string.
780
781 This function concatenates two Null-terminated ASCII strings. The contents
782 of Null-terminated ASCII string Source are concatenated to the end of Null-
783 terminated ASCII string Destination, and Destination is returned. At most,
784 Length ASCII characters are concatenated from Source to the end of
785 Destination, and Destination is always Null-terminated. If Length is 0, then
786 Destination is returned unmodified. If Source and Destination overlap, then
787 the results are undefined.
788
789 If Destination is NULL, then ASSERT().
790 If Source is NULL, then ASSERT().
791 If Source and Destination overlap, then ASSERT().
792 If PcdMaximumAsciiStringLength is not zero, and Destination contains more than
793 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
794 then ASSERT().
795 If PcdMaximumAsciiStringLength is not zero, and Source contains more than
796 PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
797 then ASSERT().
798 If PcdMaximumAsciiStringLength is not zero, and concatenating Destination and
799 Source results in a ASCII string with more than PcdMaximumAsciiStringLength
800 ASCII characters not including the Null-terminator, then ASSERT().
801
802 @param Destination Pointer to a Null-terminated ASCII string.
803 @param Source Pointer to a Null-terminated ASCII string.
804 @param Length Maximum number of ASCII characters to concatenate from
805 Source.
806
807 @return Destination
808
809 **/
810 CHAR8 *
811 EFIAPI
812 AsciiStrnCat (
813 IN OUT CHAR8 *Destination,
814 IN CONST CHAR8 *Source,
815 IN UINTN Length
816 )
817 {
818 AsciiStrnCpy (Destination + AsciiStrLen (Destination), Source, Length);
819
820 //
821 // Size of the resulting string should never be zero.
822 // PcdMaximumUnicodeStringLength is tested inside StrLen().
823 //
824 ASSERT (AsciiStrSize (Destination) != 0);
825 return Destination;
826 }
827
828 /**
829 Converts an 8-bit value to an 8-bit BCD value.
830
831 Converts the 8-bit value specified by Value to BCD. The BCD value is
832 returned.
833
834 If Value >= 100, then ASSERT().
835
836 @param Value The 8-bit value to convert to BCD. Range 0..99.
837
838 @return The BCD value
839
840 **/
841 UINT8
842 EFIAPI
843 DecimalToBcd8 (
844 IN UINT8 Value
845 )
846 {
847 ASSERT (Value < 100);
848 return ((Value / 10) << 4) | (Value % 10);
849 }
850
851 /**
852 Converts an 8-bit BCD value to an 8-bit value.
853
854 Converts the 8-bit BCD value specified by Value to an 8-bit value. The 8-bit
855 value is returned.
856
857 If Value >= 0xA0, then ASSERT().
858 If (Value & 0x0F) >= 0x0A, then ASSERT().
859
860 @param Value The 8-bit BCD value to convert to an 8-bit value.
861
862 @return The 8-bit value is returned.
863
864 **/
865 UINT8
866 EFIAPI
867 BcdToDecimal8 (
868 IN UINT8 Value
869 )
870 {
871 ASSERT (Value < 0xa0);
872 ASSERT ((Value & 0xf) < 0xa);
873 return (Value >> 4) * 10 + (Value & 0xf);
874 }
EFI Development Kit II mirror for PVE