xref: /freebsd/crypto/heimdal/lib/roken/parse_units.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
1 /*
2  * Copyright (c) 1997 - 2001 Kungliga Tekniska H�gskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #ifdef HAVE_CONFIG_H
35 #include <config.h>
36 RCSID("$Id: parse_units.c 21005 2007-06-08 01:54:35Z lha $");
37 #endif
38 
39 #include <stdio.h>
40 #include <ctype.h>
41 #include <string.h>
42 #include "roken.h"
43 #include "parse_units.h"
44 
45 /*
46  * Parse string in `s' according to `units' and return value.
47  * def_unit defines the default unit.
48  */
49 
50 static int
51 parse_something (const char *s, const struct units *units,
52 		 const char *def_unit,
53 		 int (*func)(int res, int val, unsigned mult),
54 		 int init,
55 		 int accept_no_val_p)
56 {
57     const char *p;
58     int res = init;
59     unsigned def_mult = 1;
60 
61     if (def_unit != NULL) {
62 	const struct units *u;
63 
64 	for (u = units; u->name; ++u) {
65 	    if (strcasecmp (u->name, def_unit) == 0) {
66 		def_mult = u->mult;
67 		break;
68 	    }
69 	}
70 	if (u->name == NULL)
71 	    return -1;
72     }
73 
74     p = s;
75     while (*p) {
76 	double val;
77 	char *next;
78 	const struct units *u, *partial_unit;
79 	size_t u_len;
80 	unsigned partial;
81 	int no_val_p = 0;
82 
83 	while(isspace((unsigned char)*p) || *p == ',')
84 	    ++p;
85 
86 	val = strtod (p, &next); /* strtol(p, &next, 0); */
87 	if (p == next) {
88 	    val = 0;
89 	    if(!accept_no_val_p)
90 		return -1;
91 	    no_val_p = 1;
92 	}
93 	p = next;
94 	while (isspace((unsigned char)*p))
95 	    ++p;
96 	if (*p == '\0') {
97 	    res = (*func)(res, val, def_mult);
98 	    if (res < 0)
99 		return res;
100 	    break;
101 	} else if (*p == '+') {
102 	    ++p;
103 	    val = 1;
104 	} else if (*p == '-') {
105 	    ++p;
106 	    val = -1;
107 	}
108 	if (no_val_p && val == 0)
109 	    val = 1;
110 	u_len = strcspn (p, ", \t");
111 	partial = 0;
112 	partial_unit = NULL;
113 	if (u_len > 1 && p[u_len - 1] == 's')
114 	    --u_len;
115 	for (u = units; u->name; ++u) {
116 	    if (strncasecmp (p, u->name, u_len) == 0) {
117 		if (u_len == strlen (u->name)) {
118 		    p += u_len;
119 		    res = (*func)(res, val, u->mult);
120 		    if (res < 0)
121 			return res;
122 		    break;
123 		} else {
124 		    ++partial;
125 		    partial_unit = u;
126 		}
127 	    }
128 	}
129 	if (u->name == NULL) {
130 	    if (partial == 1) {
131 		p += u_len;
132 		res = (*func)(res, val, partial_unit->mult);
133 		if (res < 0)
134 		    return res;
135 	    } else {
136 		return -1;
137 	    }
138 	}
139 	if (*p == 's')
140 	    ++p;
141     }
142     return res;
143 }
144 
145 /*
146  * The string consists of a sequence of `n unit'
147  */
148 
149 static int
150 acc_units(int res, int val, unsigned mult)
151 {
152     return res + val * mult;
153 }
154 
155 int ROKEN_LIB_FUNCTION
156 parse_units (const char *s, const struct units *units,
157 	     const char *def_unit)
158 {
159     return parse_something (s, units, def_unit, acc_units, 0, 0);
160 }
161 
162 /*
163  * The string consists of a sequence of `[+-]flag'.  `orig' consists
164  * the original set of flags, those are then modified and returned as
165  * the function value.
166  */
167 
168 static int
169 acc_flags(int res, int val, unsigned mult)
170 {
171     if(val == 1)
172 	return res | mult;
173     else if(val == -1)
174 	return res & ~mult;
175     else if (val == 0)
176 	return mult;
177     else
178 	return -1;
179 }
180 
181 int ROKEN_LIB_FUNCTION
182 parse_flags (const char *s, const struct units *units,
183 	     int orig)
184 {
185     return parse_something (s, units, NULL, acc_flags, orig, 1);
186 }
187 
188 /*
189  * Return a string representation according to `units' of `num' in `s'
190  * with maximum length `len'.  The actual length is the function value.
191  */
192 
193 static int
194 unparse_something (int num, const struct units *units, char *s, size_t len,
195 		   int (*print) (char *, size_t, int, const char *, int),
196 		   int (*update) (int, unsigned),
197 		   const char *zero_string)
198 {
199     const struct units *u;
200     int ret = 0, tmp;
201 
202     if (num == 0)
203 	return snprintf (s, len, "%s", zero_string);
204 
205     for (u = units; num > 0 && u->name; ++u) {
206 	int divisor;
207 
208 	divisor = num / u->mult;
209 	if (divisor) {
210 	    num = (*update) (num, u->mult);
211 	    tmp = (*print) (s, len, divisor, u->name, num);
212 	    if (tmp < 0)
213 		return tmp;
214 	    if (tmp > len) {
215 		len = 0;
216 		s = NULL;
217 	    } else {
218 		len -= tmp;
219 		s += tmp;
220 	    }
221 	    ret += tmp;
222 	}
223     }
224     return ret;
225 }
226 
227 static int
228 print_unit (char *s, size_t len, int divisor, const char *name, int rem)
229 {
230     return snprintf (s, len, "%u %s%s%s",
231 		     divisor, name,
232 		     divisor == 1 ? "" : "s",
233 		     rem > 0 ? " " : "");
234 }
235 
236 static int
237 update_unit (int in, unsigned mult)
238 {
239     return in % mult;
240 }
241 
242 static int
243 update_unit_approx (int in, unsigned mult)
244 {
245     if (in / mult > 0)
246 	return 0;
247     else
248 	return update_unit (in, mult);
249 }
250 
251 int ROKEN_LIB_FUNCTION
252 unparse_units (int num, const struct units *units, char *s, size_t len)
253 {
254     return unparse_something (num, units, s, len,
255 			      print_unit,
256 			      update_unit,
257 			      "0");
258 }
259 
260 int ROKEN_LIB_FUNCTION
261 unparse_units_approx (int num, const struct units *units, char *s, size_t len)
262 {
263     return unparse_something (num, units, s, len,
264 			      print_unit,
265 			      update_unit_approx,
266 			      "0");
267 }
268 
269 void ROKEN_LIB_FUNCTION
270 print_units_table (const struct units *units, FILE *f)
271 {
272     const struct units *u, *u2;
273     unsigned max_sz = 0;
274 
275     for (u = units; u->name; ++u) {
276 	max_sz = max(max_sz, strlen(u->name));
277     }
278 
279     for (u = units; u->name;) {
280 	char buf[1024];
281 	const struct units *next;
282 
283 	for (next = u + 1; next->name && next->mult == u->mult; ++next)
284 	    ;
285 
286 	if (next->name) {
287 	    for (u2 = next;
288 		 u2->name && u->mult % u2->mult != 0;
289 		 ++u2)
290 		;
291 	    if (u2->name == NULL)
292 		--u2;
293 	    unparse_units (u->mult, u2, buf, sizeof(buf));
294 	    fprintf (f, "1 %*s = %s\n", max_sz, u->name, buf);
295 	} else {
296 	    fprintf (f, "1 %s\n", u->name);
297 	}
298 	u = next;
299     }
300 }
301 
302 static int
303 print_flag (char *s, size_t len, int divisor, const char *name, int rem)
304 {
305     return snprintf (s, len, "%s%s", name, rem > 0 ? ", " : "");
306 }
307 
308 static int
309 update_flag (int in, unsigned mult)
310 {
311     return in - mult;
312 }
313 
314 int ROKEN_LIB_FUNCTION
315 unparse_flags (int num, const struct units *units, char *s, size_t len)
316 {
317     return unparse_something (num, units, s, len,
318 			      print_flag,
319 			      update_flag,
320 			      "");
321 }
322 
323 void ROKEN_LIB_FUNCTION
324 print_flags_table (const struct units *units, FILE *f)
325 {
326     const struct units *u;
327 
328     for(u = units; u->name; ++u)
329 	fprintf(f, "%s%s", u->name, (u+1)->name ? ", " : "\n");
330 }
331