ncurses 5.3
[ncurses.git] / ncurses / base / safe_sprintf.c
1 /****************************************************************************
2  * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc.              *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /****************************************************************************
30  *  Author: Thomas E. Dickey <dickey@clark.net> 1997                        *
31  ****************************************************************************/
32
33 #include <curses.priv.h>
34 #include <ctype.h>
35
36 MODULE_ID("$Id: safe_sprintf.c,v 1.14 2001/07/08 00:58:34 tom Exp $")
37
38 #if USE_SAFE_SPRINTF
39
40 typedef enum {
41     Flags, Width, Prec, Type, Format
42 } PRINTF;
43
44 #define VA_INTGR(type) ival = va_arg(ap, type)
45 #define VA_FLOAT(type) fval = va_arg(ap, type)
46 #define VA_POINT(type) pval = (void *)va_arg(ap, type)
47
48 /*
49  * Scan a variable-argument list for printf to determine the number of
50  * characters that would be emitted.
51  */
52 static int
53 _nc_printf_length(const char *fmt, va_list ap)
54 {
55     size_t length = BUFSIZ;
56     char *buffer;
57     char *format;
58     int len = 0;
59
60     if (fmt == 0 || *fmt == '\0')
61         return -1;
62     if ((format = typeMalloc(char, strlen(fmt) + 1)) == 0)
63           return -1;
64     if ((buffer = typeMalloc(char, length)) == 0) {
65         free(format);
66         return -1;
67     }
68
69     while (*fmt != '\0') {
70         if (*fmt == '%') {
71             static char dummy[] = "";
72             PRINTF state = Flags;
73             char *pval = dummy; /* avoid const-cast */
74             double fval = 0.0;
75             int done = FALSE;
76             int ival = 0;
77             int prec = -1;
78             int type = 0;
79             int used = 0;
80             int width = -1;
81             size_t f = 0;
82
83             format[f++] = *fmt;
84             while (*++fmt != '\0' && len >= 0 && !done) {
85                 format[f++] = *fmt;
86
87                 if (isdigit(UChar(*fmt))) {
88                     int num = *fmt - '0';
89                     if (state == Flags && num != 0)
90                         state = Width;
91                     if (state == Width) {
92                         if (width < 0)
93                             width = 0;
94                         width = (width * 10) + num;
95                     } else if (state == Prec) {
96                         if (prec < 0)
97                             prec = 0;
98                         prec = (prec * 10) + num;
99                     }
100                 } else if (*fmt == '*') {
101                     VA_INTGR(int);
102                     if (state == Flags)
103                         state = Width;
104                     if (state == Width) {
105                         width = ival;
106                     } else if (state == Prec) {
107                         prec = ival;
108                     }
109                     sprintf(&format[--f], "%d", ival);
110                     f = strlen(format);
111                 } else if (isalpha(UChar(*fmt))) {
112                     done = TRUE;
113                     switch (*fmt) {
114                     case 'Z':   /* FALLTHRU */
115                     case 'h':   /* FALLTHRU */
116                     case 'l':   /* FALLTHRU */
117                         done = FALSE;
118                         type = *fmt;
119                         break;
120                     case 'i':   /* FALLTHRU */
121                     case 'd':   /* FALLTHRU */
122                     case 'u':   /* FALLTHRU */
123                     case 'x':   /* FALLTHRU */
124                     case 'X':   /* FALLTHRU */
125                         if (type == 'l')
126                             VA_INTGR(long);
127                         else if (type == 'Z')
128                             VA_INTGR(size_t);
129                         else
130                             VA_INTGR(int);
131                         used = 'i';
132                         break;
133                     case 'f':   /* FALLTHRU */
134                     case 'e':   /* FALLTHRU */
135                     case 'E':   /* FALLTHRU */
136                     case 'g':   /* FALLTHRU */
137                     case 'G':   /* FALLTHRU */
138                         VA_FLOAT(double);
139                         used = 'f';
140                         break;
141                     case 'c':
142                         VA_INTGR(int);
143                         used = 'i';
144                         break;
145                     case 's':
146                         VA_POINT(char *);
147                         if (prec < 0)
148                             prec = strlen(pval);
149                         if (prec > (int) length) {
150                             length = length + prec;
151                             buffer = typeRealloc(char, length, buffer);
152                             if (buffer == 0) {
153                                 free(format);
154                                 return -1;
155                             }
156                         }
157                         used = 'p';
158                         break;
159                     case 'p':
160                         VA_POINT(void *);
161                         used = 'p';
162                         break;
163                     case 'n':
164                         VA_POINT(int *);
165                         used = 0;
166                         break;
167                     default:
168                         break;
169                     }
170                 } else if (*fmt == '.') {
171                     state = Prec;
172                 } else if (*fmt == '%') {
173                     done = TRUE;
174                     used = 'p';
175                 }
176             }
177             format[f] = '\0';
178             switch (used) {
179             case 'i':
180                 sprintf(buffer, format, ival);
181                 break;
182             case 'f':
183                 sprintf(buffer, format, fval);
184                 break;
185             default:
186                 sprintf(buffer, format, pval);
187                 break;
188             }
189             len += (int) strlen(buffer);
190         } else {
191             fmt++;
192             len++;
193         }
194     }
195
196     free(buffer);
197     free(format);
198     return len;
199 }
200 #endif
201
202 /*
203  * Wrapper for vsprintf that allocates a buffer big enough to hold the result.
204  */
205 NCURSES_EXPORT(char *)
206 _nc_printf_string
207 (const char *fmt, va_list ap)
208 {
209 #if USE_SAFE_SPRINTF
210     char *buf = 0;
211     int len = _nc_printf_length(fmt, ap);
212
213     if (len > 0) {
214         if ((buf = typeMalloc(char, len + 1)) == 0)
215               return (0);
216         vsprintf(buf, fmt, ap);
217     }
218 #else
219     static int rows, cols;
220     static char *buf;
221     static size_t len;
222
223     if (screen_lines > rows || screen_columns > cols) {
224         if (screen_lines > rows)
225             rows = screen_lines;
226         if (screen_columns > cols)
227             cols = screen_columns;
228         len = (rows * (cols + 1)) + 1;
229         buf = typeRealloc(char, len, buf);
230         if (buf == 0) {
231             return (0);
232         }
233     }
234
235     if (buf != 0) {
236 # if HAVE_VSNPRINTF
237         vsnprintf(buf, len, fmt, ap);   /* GNU extension */
238 # else
239         vsprintf(buf, fmt, ap); /* ANSI */
240 # endif
241     }
242 #endif
243     return buf;
244 }