| blob | fbceebd5b921e481311d445da00e044b2dc1b591 |
1 /*
2 * libString, Copyright (C) 1999 Patrick Alken
3 * This library comes with absolutely NO WARRANTY
4 *
5 * Should you choose to use and/or modify this source code, please
6 * do so under the terms of the GNU General Public License under which
7 * this library is distributed.
8 *
9 * $Id: snprintf.c 26 2006-09-20 18:02:06Z spb $
10 */
12 #include <stdio.h>
13 #include <stdarg.h>
14 #include <stdlib.h>
15 #include <sys/types.h>
16 #include <ctype.h>
20 /*
21 * This table is arranged in chronological order from 0-999,
22 * however the numbers are written backwards, so the number 100
23 * is expressed in this table as "001".
24 * It's purpose is to ensure fast conversions from integers to
25 * ASCII strings. When an integer variable is encountered, a
26 * simple hash algorithm is used to determine where to look
27 * in this array for the corresponding string.
28 * This outperforms continually dividing by 10 and using the
29 * digit obtained as a character, because we can now divide by
30 * 1000 and use the remainder directly, thus cutting down on
31 * the number of costly divisions needed. For an integer's worst
32 * case, 2 divisions are needed because it can only go up to
33 * 32767, so after 2 divisions by 1000, and some algebra, we will
34 * be left with 327 which we can get from this table. This is much
35 * better than the 5 divisions by 10 that we would need if we did
36 * it the conventional way. Of course, if we made this table go
37 * from 0-9999, only 1 division would be needed.
38 * Longs and unsigned ints of course, are another matter :-).
39 *
40 * Patrick Alken <wnder@underworld.net>
41 */
43 /*
44 * Set this to the number of indices (numbers) in our table
45 */
46 #define TABLE_MAX 1000
249 };
251 /*
252 * Since we calculate the right-most digits for %d %u etc first,
253 * we need a temporary buffer to store them in until we get
254 * to the left-most digits
255 */
257 #define TEMPBUF_MAX 20
261 /*
262 vSnprintf()
263 Backend to Snprintf() - performs the construction of 'dest'
264 using the string 'format' and the given arguments. Also makes sure
265 not more than 'bytes' characters are copied to 'dest'
267 We always allow room for a terminating \0 character, so at most,
268 bytes - 1 characters will be written to dest.
270 Return: Number of characters written, NOT including the terminating
271 \0 character which is *always* placed at the end of the string
273 NOTE: This function handles the following flags only:
274 %s %d %c %u %ld %lu
275 In addition, this function performs *NO* precision, padding,
276 or width formatting. If it receives an unknown % character,
277 it will call vsprintf() to complete the remainder of the
278 string.
279 */
281 int
283 {
289 {
291 {
292 /*
293 * Advance past the %
294 */
297 /*
298 * Put the most common cases first - %s %d etc
299 */
302 {
306 {
312 }
315 }
318 {
324 /*
325 * We have to special-case "0" unfortunately
326 */
328 {
332 }
335 {
341 }
343 do
344 {
347 /*
348 * We'll start with the right-most digits of 'num'.
349 * Dividing by TABLE_MAX cuts off all but the X
350 * right-most digits, where X is such that:
351 *
352 * 10^X = TABLE_MAX
353 *
354 * For example, if num = 1200, and TABLE_MAX = 1000,
355 * quotient will be 1. Multiplying this by 1000 and
356 * subtracting from 1200 gives: 1200 - (1 * 1000) = 200.
357 * We then go right to slot 200 in our array and behold!
358 * The string "002" (200 backwards) is conveniently
359 * waiting for us. Then repeat the process with the
360 * digits left.
361 *
362 * The reason we need to have the integers written
363 * backwards, is because we don't know how many digits
364 * there are. If we want to express the number 12130
365 * for example, our first pass would leave us with 130,
366 * whose slot in the array yields "031", which we
367 * plug into our TempBuffer[]. The next pass gives us
368 * 12, whose slot yields "21" which we append to
369 * TempBuffer[], leaving us with "03121". This is the
370 * exact number we want, only backwards, so it is
371 * a simple matter to reverse the string. If we used
372 * straightfoward numbers, we would have a TempBuffer
373 * looking like this: "13012" which would be a nightmare
374 * to deal with.
375 */
380 {
383 }
384 }
387 /*
388 * If the last quotient was a 1 or 2 digit number, there
389 * will be one or more leading zeroes in TempBuffer[] -
390 * get rid of them.
391 */
396 {
400 }
406 {
415 {
422 {
426 }
428 do
429 {
432 /*
433 * Very similar to case 'd'
434 */
439 {
442 }
443 }
450 {
454 }
460 {
462 {
471 {
475 }
477 do
478 {
481 /*
482 * Very similar to case 'u'
483 */
488 {
491 }
492 }
499 {
503 }
509 {
518 {
522 }
525 {
531 }
533 do
534 {
540 {
543 }
544 }
551 {
555 }
559 {
562 #ifdef HAVE_VSNPRINTF
564 #else
566 #endif
570 }
576 {
579 /*
580 * The character might be invalid, or be a precision,
581 * padding, or width specification - call vsprintf()
582 * to finish off the string
583 */
586 #ifdef HAVE_VSNPRINTF
588 #else
590 #endif
602 /*
603 * Terminate the destination buffer with a \0
604 */
610 /*
611 ircvsprintf()
612 Backend to Sprintf() - performs the construction of 'dest'
613 using the string 'format' and the given arguments.
615 We always place a \0 character onto the end of 'dest'.
617 Return: Number of characters written, NOT including the terminating
618 \0 character which is *always* placed at the end of the string
620 NOTE: This function handles the following flags only:
621 %s %d %c %u %ld %lu
622 In addition, this function performs *NO* precision, padding,
623 or width formatting. If it receives an unknown % character,
624 it will call vsprintf() to complete the remainder of the
625 string.
626 */
628 int
630 {
635 {
637 {
638 /*
639 * Advance past the %
640 */
643 /*
644 * Put the most common cases first - %s %d etc
645 */
648 {
652 {
657 }
664 {
670 /*
671 * We have to special-case "0" unfortunately
672 */
674 {
678 }
681 {
686 }
688 do
689 {
692 /*
693 * We'll start with the right-most digits of 'num'.
694 * Dividing by TABLE_MAX cuts off all but the X
695 * right-most digits, where X is such that:
696 *
697 * 10^X = TABLE_MAX
698 *
699 * For example, if num = 1200, and TABLE_MAX = 1000,
700 * quotient will be 1. Multiplying this by 1000 and
701 * subtracting from 1200 gives: 1200 - (1 * 1000) = 200.
702 * We then go right to slot 200 in our array and behold!
703 * The string "002" (200 backwards) is conveniently
704 * waiting for us. Then repeat the process with the
705 * digits left.
706 *
707 * The reason we need to have the integers written
708 * backwards, is because we don't know how many digits
709 * there are. If we want to express the number 12130
710 * for example, our first pass would leave us with 130,
711 * whose slot in the array yields "031", which we
712 * plug into our TempBuffer[]. The next pass gives us
713 * 12, whose slot yields "21" which we append to
714 * TempBuffer[], leaving us with "03121". This is the
715 * exact number we want, only backwards, so it is
716 * a simple matter to reverse the string. If we used
717 * straightfoward numbers, we would have a TempBuffer
718 * looking like this: "13012" which would be a nightmare
719 * to deal with.
720 */
725 {
728 }
729 }
732 /*
733 * If the last quotient was a 1 or 2 digit number, there
734 * will be one or more leading zeroes in TempBuffer[] -
735 * get rid of them.
736 */
741 {
744 }
750 {
759 {
766 {
770 }
772 do
773 {
776 /*
777 * Very similar to case 'd'
778 */
783 {
786 }
787 }
794 {
797 }
803 {
805 {
814 {
818 }
820 do
821 {
824 /*
825 * Very similar to case 'u'
826 */
831 {
834 }
835 }
842 {
845 }
851 {
860 {
864 }
867 {
872 }
874 do
875 {
881 {
884 }
885 }
892 {
895 }
904 {
920 /*
921 * Terminate the destination buffer with a \0
922 */
928 /*
929 ircsnprintf()
930 Optimized version of snprintf().
932 Inputs: dest - destination string
933 bytes - number of bytes to copy
934 format - formatted string
935 args - args to 'format'
937 Return: number of characters copied, NOT including the terminating
938 NULL which is always placed at the end of the string
939 */
941 int
943 {
956 /*
957 ircsprintf()
958 Optimized version of sprintf()
960 Inputs: dest - destination string
961 format - formatted string
962 args - arguments to 'format'
964 Return: number of characters copied, NOT including the terminating
965 NULL which is always placed at the end of the string
966 */
968 int
970 {