2 * Copyright 2013 Garrett D'Amore <garrett@damore.org>
3 * Copyright 2010 Nexenta Systems, Inc. All rights reserved.
4 * Copyright (c) 2001 Alexey Zelkin <phantom@FreeBSD.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #include <sys/types.h>
45 #include "localeimpl.h"
46 #include "lmonetary.h"
50 #define NEED_GROUPING 0x01 /* print digits grouped (default) */
51 #define SIGN_POSN_USED 0x02 /* '+' or '(' usage flag */
52 #define LOCALE_POSN 0x04 /* use locale defined +/- (default) */
53 #define PARENTH_POSN 0x08 /* enclose negative amount in () */
54 #define SUPRESS_CURR_SYMBOL 0x10 /* supress the currency from output */
55 #define LEFT_JUSTIFY 0x20 /* left justify */
56 #define USE_INTL_CURRENCY 0x40 /* use international currency symbol */
57 #define IS_NEGATIVE 0x80 /* is argument value negative ? */
61 if (dst >= s + maxsize) \
66 #define PRINTS(STR) { \
67 const char *tmps = STR; \
68 while (*tmps != '\0') \
72 #define GET_NUMBER(VAR) { \
74 while (isdigit((unsigned char)*fmt)) { \
75 if (VAR > INT_MAX / 10) \
85 #define GRPCPY(howmany) { \
89 *--bufend = *(avalue+avalue_size+padded); \
94 bufend -= thousands_len; \
95 (void) memcpy(bufend, thousands_sep, thousands_len); \
99 static void setup_vars(const struct lc_monetary
*, int, char *, char *, char *,
101 static int calc_left_pad(const struct lc_monetary
*, int, const char *);
102 static char *format_grouped_double(const struct lc_monetary
*,
103 const struct lc_numeric
*, double, int *, int, int, int);
106 strfmon_impl(char *_RESTRICT_KYWD s
, size_t maxsize
, locale_t loc
,
107 const char *_RESTRICT_KYWD format
, va_list ap
)
109 char *dst
; /* output destination pointer */
110 const char *fmt
; /* current format poistion pointer */
111 char *asciivalue
; /* formatted double pointer */
113 int flags
; /* formatting options */
114 int pad_char
; /* padding character */
115 int pad_size
; /* pad size */
116 int width
; /* field width */
117 int left_prec
; /* left precision */
118 int right_prec
; /* right precision */
119 double value
; /* just value */
120 char space_char
= ' '; /* space after currency */
122 char cs_precedes
; /* values from struct lc_monetary */
126 const char *currency_symbol
;
128 char *tmpptr
; /* temporary vars */
130 const struct lc_monetary
*lmon
; /* monetary structure */
131 const struct lc_numeric
*lnum
; /* numeric structure */
133 lmon
= loc
->monetary
;
139 currency_symbol
= NULL
;
143 /* pass nonformating characters AS IS */
149 /* "%%" mean just '%' */
150 if (*(fmt
+1) == '%') {
157 /* set up initial values */
158 flags
= (NEED_GROUPING
|LOCALE_POSN
);
159 pad_char
= ' '; /* padding character is "space" */
160 left_prec
= -1; /* no left precision specified */
161 right_prec
= -1; /* no right precision specified */
162 width
= -1; /* no width specified */
163 value
= 0; /* we have no value to print now */
168 case '=': /* fill character */
170 if (pad_char
== '\0')
173 case '^': /* not group currency */
174 flags
&= ~(NEED_GROUPING
);
176 case '+': /* use locale defined signs */
177 if (flags
& SIGN_POSN_USED
)
179 flags
|= (SIGN_POSN_USED
|LOCALE_POSN
);
181 case '(': /* enclose negatives with () */
182 if (flags
& SIGN_POSN_USED
)
184 flags
|= (SIGN_POSN_USED
|PARENTH_POSN
);
186 case '!': /* suppress currency symbol */
187 flags
|= SUPRESS_CURR_SYMBOL
;
189 case '-': /* alignment (left) */
190 flags
|= LEFT_JUSTIFY
;
199 if (isdigit((unsigned char)*fmt
)) {
202 * Do we have enough space to put number with
205 if ((unsigned int)width
>= maxsize
- (dst
- s
))
211 if (!isdigit((unsigned char)*++fmt
))
213 GET_NUMBER(left_prec
);
214 if ((unsigned int)left_prec
>= maxsize
- (dst
- s
))
218 /* Right precision */
220 if (!isdigit((unsigned char)*++fmt
))
222 GET_NUMBER(right_prec
);
223 if ((unsigned int)right_prec
>= maxsize
- (dst
- s
) -
228 /* Conversion Characters */
230 case 'i': /* use internaltion currency format */
231 flags
|= USE_INTL_CURRENCY
;
233 case 'n': /* use national currency format */
234 flags
&= ~(USE_INTL_CURRENCY
);
237 /* required char missing or premature EOS */
241 if (flags
& USE_INTL_CURRENCY
) {
242 currency_symbol
= lmon
->int_curr_symbol
;
243 /* by definition three letters followed by a space */
244 if (currency_symbol
!= NULL
)
245 space_char
= currency_symbol
[3];
247 currency_symbol
= lmon
->currency_symbol
;
250 value
= va_arg(ap
, double);
254 flags
|= IS_NEGATIVE
;
258 /* fill left_prec with amount of padding chars */
259 if (left_prec
>= 0) {
260 pad_size
= calc_left_pad(lmon
, (flags
^ IS_NEGATIVE
),
262 calc_left_pad(lmon
, flags
, currency_symbol
);
267 if (asciivalue
!= NULL
)
269 asciivalue
= format_grouped_double(lmon
, lnum
, value
, &flags
,
270 left_prec
, right_prec
, pad_char
);
271 if (asciivalue
== NULL
)
272 goto end_error
; /* errno already set */
273 /* to ENOMEM by malloc() */
275 /* set some variables for later use */
276 setup_vars(lmon
, flags
, &cs_precedes
, &sep_by_space
,
277 &sign_posn
, &signstr
);
280 * Description of some LC_MONETARY's values:
282 * p_cs_precedes & n_cs_precedes
284 * = 1 - $currency_symbol precedes the value
285 * for a monetary quantity with a non-negative value
286 * = 0 - symbol succeeds the value
288 * p_sep_by_space & n_sep_by_space
290 * = 0 - no space separates $currency_symbol
291 * from the value for a monetary quantity with a
293 * = 1 - space separates the symbol from the value
294 * = 2 - space separates the symbol and the sign string,
297 * p_sign_posn & n_sign_posn
299 * = 0 - parentheses enclose the quantity and the
301 * = 1 - the sign string precedes the quantity and the
303 * = 2 - the sign string succeeds the quantity and the
305 * = 3 - the sign string precedes the $currency_symbol
306 * = 4 - the sign string succeeds the $currency_symbol
312 while (pad_size
-- > 0)
315 if (sign_posn
== 0 && (flags
& IS_NEGATIVE
))
318 if (cs_precedes
== 1) {
319 if (sign_posn
== 1 || sign_posn
== 3) {
321 if (sep_by_space
== 2)
325 if (!(flags
& SUPRESS_CURR_SYMBOL
)) {
326 PRINTS(currency_symbol
);
328 if (sign_posn
== 4) {
329 if (sep_by_space
== 2)
332 if (sep_by_space
== 1)
334 } else if (sep_by_space
== 1)
337 } else if (sign_posn
== 1)
342 if (cs_precedes
== 0) {
343 if (sign_posn
== 3) {
344 if (sep_by_space
== 1)
349 if (!(flags
& SUPRESS_CURR_SYMBOL
)) {
350 if ((sign_posn
== 3 && sep_by_space
== 2) ||
351 (sep_by_space
== 1 && (sign_posn
== 0 ||
352 sign_posn
== 1 || sign_posn
== 2 ||
355 PRINTS(currency_symbol
); /* XXX: len */
356 if (sign_posn
== 4) {
357 if (sep_by_space
== 2)
364 if (sign_posn
== 2) {
365 if (sep_by_space
== 2)
370 if (sign_posn
== 0 && (flags
& IS_NEGATIVE
))
373 if (dst
- tmpptr
< width
) {
374 if (flags
& LEFT_JUSTIFY
) {
375 while (dst
- tmpptr
< width
)
378 pad_size
= dst
-tmpptr
;
379 (void) memmove(tmpptr
+ width
-pad_size
, tmpptr
,
381 (void) memset(tmpptr
, ' ', width
-pad_size
);
382 dst
+= width
-pad_size
;
389 return (dst
- s
- 1); /* size of put data except trailing '\0' */
400 if (asciivalue
!= NULL
)
407 strfmon(char *_RESTRICT_KYWD s
, size_t maxsize
,
408 const char *_RESTRICT_KYWD format
, ...)
413 va_start(ap
, format
);
414 ret
= strfmon_impl(s
, maxsize
, uselocale(NULL
), format
, ap
);
420 strfmon_l(char *_RESTRICT_KYWD s
, size_t maxsize
, locale_t loc
,
421 const char *_RESTRICT_KYWD format
, ...)
425 va_start(ap
, format
);
426 ret
= strfmon_impl(s
, maxsize
, loc
, format
, ap
);
432 setup_vars(const struct lc_monetary
*lmon
, int flags
, char *cs_precedes
,
433 char *sep_by_space
, char *sign_posn
, const char **signstr
)
435 if ((flags
& IS_NEGATIVE
) && (flags
& USE_INTL_CURRENCY
)) {
436 *cs_precedes
= lmon
->int_n_cs_precedes
[0];
437 *sep_by_space
= lmon
->int_n_sep_by_space
[0];
438 *sign_posn
= (flags
& PARENTH_POSN
) ? 0 :
439 lmon
->int_n_sign_posn
[0];
440 *signstr
= (lmon
->negative_sign
[0] == '\0') ? "-" :
442 } else if (flags
& USE_INTL_CURRENCY
) {
443 *cs_precedes
= lmon
->int_p_cs_precedes
[0];
444 *sep_by_space
= lmon
->int_p_sep_by_space
[0];
445 *sign_posn
= (flags
& PARENTH_POSN
) ? 0 :
446 lmon
->int_p_sign_posn
[0];
447 *signstr
= lmon
->positive_sign
;
448 } else if (flags
& IS_NEGATIVE
) {
449 *cs_precedes
= lmon
->n_cs_precedes
[0];
450 *sep_by_space
= lmon
->n_sep_by_space
[0];
451 *sign_posn
= (flags
& PARENTH_POSN
) ? 0 : lmon
->n_sign_posn
[0];
452 *signstr
= (lmon
->negative_sign
[0] == '\0') ? "-" :
455 *cs_precedes
= lmon
->p_cs_precedes
[0];
456 *sep_by_space
= lmon
->p_sep_by_space
[0];
457 *sign_posn
= (flags
& PARENTH_POSN
) ? 0 : lmon
->p_sign_posn
[0];
458 *signstr
= lmon
->positive_sign
;
461 /* Set default values for unspecified information. */
462 if (*cs_precedes
!= 0)
464 if (*sep_by_space
== CHAR_MAX
)
466 if (*sign_posn
== CHAR_MAX
)
471 calc_left_pad(const struct lc_monetary
*lmon
, int flags
, const char *cur_symb
)
473 char cs_precedes
, sep_by_space
, sign_posn
;
477 setup_vars(lmon
, flags
, &cs_precedes
, &sep_by_space
, &sign_posn
,
480 if (cs_precedes
!= 0) {
481 left_chars
+= strlen(cur_symb
);
482 if (sep_by_space
!= 0)
488 left_chars
+= strlen(signstr
);
492 if (cs_precedes
!= 0)
493 left_chars
+= strlen(signstr
);
499 get_groups(int size
, const char *grouping
)
504 if (*grouping
== CHAR_MAX
|| *grouping
<= 0) /* no grouping ? */
507 while (size
> (int)*grouping
) {
509 size
-= (int)*grouping
++;
510 /* no more grouping ? */
511 if (*grouping
== CHAR_MAX
)
513 /* rest grouping with same value ? */
514 if (*grouping
== 0) {
515 chars
+= (size
- 1) / *(grouping
- 1);
522 /* convert double to ASCII */
524 format_grouped_double(const struct lc_monetary
*lmon
,
525 const struct lc_numeric
*lnum
,
526 double value
, int *flags
, int left_prec
, int right_prec
, int pad_char
)
539 const char *grouping
;
540 const char *decimal_point
;
541 const char *thousands_sep
;
547 grouping
= lmon
->mon_grouping
;
548 decimal_point
= lmon
->mon_decimal_point
;
549 if (*decimal_point
== '\0')
550 decimal_point
= lnum
->decimal_point
;
551 thousands_sep
= lmon
->mon_thousands_sep
;
552 if (*thousands_sep
== '\0')
553 thousands_sep
= lnum
->thousands_sep
;
555 decimal_len
= strlen(decimal_point
); /* usually 1 */
556 thousands_len
= strlen(thousands_sep
); /* 0 or 1 usually */
558 /* fill left_prec with default value */
562 /* fill right_prec with default value */
563 if (right_prec
== -1) {
564 if (*flags
& USE_INTL_CURRENCY
)
565 right_prec
= lmon
->int_frac_digits
[0];
567 right_prec
= lmon
->frac_digits
[0];
569 if (right_prec
== CHAR_MAX
) /* POSIX locale ? */
573 if (*flags
& NEED_GROUPING
)
574 left_prec
+= get_groups(left_prec
, grouping
);
576 /* convert to string */
577 (void) snprintf(fmt
, sizeof (fmt
), "%%%d.%df",
578 left_prec
+ right_prec
+ 1, right_prec
);
579 avalue_size
= asprintf(&avalue
, fmt
, value
);
584 * Make sure that we've enough space for result string.
585 * This assumes that digits take up at least much space as
586 * grouping and radix characters. The worst case currently known
587 * is for Arabic, where two-byte UTF-8 sequences are used for both
588 * decimal and thousands seperators, and groups can be a small as two
589 * decimal digits. This will do no worse than doubling the storage
592 bufsize
= strlen(avalue
)*2+1;
593 rslt
= calloc(1, bufsize
);
598 bufend
= rslt
+ bufsize
- 1; /* reserve space for trailing '\0' */
600 /* skip spaces at beginning */
602 while (avalue
[padded
] == ' ') {
607 if (right_prec
> 0) {
608 bufend
-= right_prec
;
609 (void) memcpy(bufend
, avalue
+ avalue_size
+padded
-right_prec
,
611 bufend
-= decimal_len
;
612 (void) memcpy(bufend
, decimal_point
, decimal_len
);
613 avalue_size
-= (right_prec
+ decimal_len
);
616 if ((*flags
& NEED_GROUPING
) &&
617 thousands_len
!= 0 &&
618 *grouping
!= CHAR_MAX
&&
620 while (avalue_size
> (int)*grouping
) {
625 /* no more grouping ? */
626 if (*grouping
== CHAR_MAX
)
629 /* rest grouping with same value ? */
630 if (*grouping
== 0) {
632 while (avalue_size
> *grouping
) {
638 if (avalue_size
!= 0)
643 bufend
-= avalue_size
;
644 (void) memcpy(bufend
, avalue
+padded
, avalue_size
);
646 padded
--; /* decrease assumed $decimal_point */
649 /* do padding with pad_char */
652 (void) memset(bufend
, pad_char
, padded
);
655 bufsize
= bufsize
- (bufend
- rslt
) + 1;
656 (void) memmove(rslt
, bufend
, bufsize
);