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 : #include <config.h>
35 :
36 : #include <stdio.h>
37 : #include <ctype.h>
38 : #include <string.h>
39 : #include "roken.h"
40 : #include "parse_units.h"
41 :
42 : /*
43 : * Parse string in `s' according to `units' and return value.
44 : * def_unit defines the default unit.
45 : */
46 :
47 : static int
48 : parse_something (const char *s, const struct units *units,
49 : const char *def_unit,
50 : int (*func)(int res, int val, unsigned mult),
51 : int init,
52 : int accept_no_val_p)
53 0 : {
54 : const char *p;
55 0 : int res = init;
56 0 : unsigned def_mult = 1;
57 :
58 0 : if (def_unit != NULL) {
59 : const struct units *u;
60 :
61 0 : for (u = units; u->name; ++u) {
62 0 : if (strcasecmp (u->name, def_unit) == 0) {
63 0 : def_mult = u->mult;
64 0 : break;
65 : }
66 : }
67 0 : if (u->name == NULL)
68 0 : return -1;
69 : }
70 :
71 0 : p = s;
72 0 : while (*p) {
73 : int val;
74 : char *next;
75 : const struct units *u, *partial_unit;
76 : size_t u_len;
77 : unsigned partial;
78 0 : int no_val_p = 0;
79 :
80 0 : while(isspace((unsigned char)*p) || *p == ',')
81 0 : ++p;
82 :
83 0 : val = strtol(p, &next, 0);
84 0 : if (p == next) {
85 0 : val = 0;
86 0 : if(!accept_no_val_p)
87 0 : return -1;
88 0 : no_val_p = 1;
89 : }
90 0 : p = next;
91 0 : while (isspace((unsigned char)*p))
92 0 : ++p;
93 0 : if (*p == '\0') {
94 0 : res = (*func)(res, val, def_mult);
95 0 : if (res < 0)
96 0 : return res;
97 0 : break;
98 0 : } else if (*p == '+') {
99 0 : ++p;
100 0 : val = 1;
101 0 : } else if (*p == '-') {
102 0 : ++p;
103 0 : val = -1;
104 : }
105 0 : if (no_val_p && val == 0)
106 0 : val = 1;
107 0 : u_len = strcspn (p, ", \t");
108 0 : partial = 0;
109 0 : partial_unit = NULL;
110 0 : if (u_len > 1 && p[u_len - 1] == 's')
111 0 : --u_len;
112 0 : for (u = units; u->name; ++u) {
113 0 : if (strncasecmp (p, u->name, u_len) == 0) {
114 0 : if (u_len == strlen (u->name)) {
115 0 : p += u_len;
116 0 : res = (*func)(res, val, u->mult);
117 0 : if (res < 0)
118 0 : return res;
119 0 : break;
120 : } else {
121 0 : ++partial;
122 0 : partial_unit = u;
123 : }
124 : }
125 : }
126 0 : if (u->name == NULL) {
127 0 : if (partial == 1) {
128 0 : p += u_len;
129 0 : res = (*func)(res, val, partial_unit->mult);
130 0 : if (res < 0)
131 0 : return res;
132 : } else {
133 0 : return -1;
134 : }
135 : }
136 0 : if (*p == 's')
137 0 : ++p;
138 : }
139 0 : return res;
140 : }
141 :
142 : /*
143 : * The string consists of a sequence of `n unit'
144 : */
145 :
146 : static int
147 : acc_units(int res, int val, unsigned mult)
148 0 : {
149 0 : return res + val * mult;
150 : }
151 :
152 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
153 : parse_units (const char *s, const struct units *units,
154 : const char *def_unit)
155 0 : {
156 0 : return parse_something (s, units, def_unit, acc_units, 0, 0);
157 : }
158 :
159 : /*
160 : * The string consists of a sequence of `[+-]flag'. `orig' consists
161 : * the original set of flags, those are then modified and returned as
162 : * the function value.
163 : */
164 :
165 : static int
166 : acc_flags(int res, int val, unsigned mult)
167 0 : {
168 0 : if(val == 1)
169 0 : return res | mult;
170 0 : else if(val == -1)
171 0 : return res & ~mult;
172 0 : else if (val == 0)
173 0 : return mult;
174 : else
175 0 : return -1;
176 : }
177 :
178 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
179 : parse_flags (const char *s, const struct units *units,
180 : int orig)
181 0 : {
182 0 : return parse_something (s, units, NULL, acc_flags, orig, 1);
183 : }
184 :
185 : /*
186 : * Return a string representation according to `units' of `num' in `s'
187 : * with maximum length `len'. The actual length is the function value.
188 : */
189 :
190 : static int
191 : unparse_something (int num, const struct units *units, char *s, size_t len,
192 : int (*print) (char *, size_t, int, const char *, int),
193 : int (*update) (int, unsigned),
194 : const char *zero_string)
195 0 : {
196 : const struct units *u;
197 0 : int ret = 0, tmp;
198 :
199 0 : if (num == 0)
200 0 : return snprintf (s, len, "%s", zero_string);
201 :
202 0 : for (u = units; num > 0 && u->name; ++u) {
203 : int divisor;
204 :
205 0 : divisor = num / u->mult;
206 0 : if (divisor) {
207 0 : num = (*update) (num, u->mult);
208 0 : tmp = (*print) (s, len, divisor, u->name, num);
209 0 : if (tmp < 0)
210 0 : return tmp;
211 0 : if (tmp > (int) len) {
212 0 : len = 0;
213 0 : s = NULL;
214 : } else {
215 0 : len -= tmp;
216 0 : s += tmp;
217 : }
218 0 : ret += tmp;
219 : }
220 : }
221 0 : return ret;
222 : }
223 :
224 : static int
225 : print_unit (char *s, size_t len, int divisor, const char *name, int rem)
226 0 : {
227 0 : return snprintf (s, len, "%u %s%s%s",
228 : divisor, name,
229 : divisor == 1 ? "" : "s",
230 : rem > 0 ? " " : "");
231 : }
232 :
233 : static int
234 : update_unit (int in, unsigned mult)
235 0 : {
236 0 : return in % mult;
237 : }
238 :
239 : static int
240 : update_unit_approx (int in, unsigned mult)
241 0 : {
242 0 : if (in / mult > 0)
243 0 : return 0;
244 : else
245 0 : return update_unit (in, mult);
246 : }
247 :
248 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
249 : unparse_units (int num, const struct units *units, char *s, size_t len)
250 0 : {
251 0 : return unparse_something (num, units, s, len,
252 : print_unit,
253 : update_unit,
254 : "0");
255 : }
256 :
257 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
258 : unparse_units_approx (int num, const struct units *units, char *s, size_t len)
259 0 : {
260 0 : return unparse_something (num, units, s, len,
261 : print_unit,
262 : update_unit_approx,
263 : "0");
264 : }
265 :
266 : ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
267 : print_units_table (const struct units *units, FILE *f)
268 0 : {
269 : const struct units *u, *u2;
270 0 : int max_sz = 0;
271 :
272 0 : for (u = units; u->name; ++u) {
273 0 : max_sz = max(max_sz, strlen(u->name));
274 : }
275 :
276 0 : for (u = units; u->name;) {
277 : char buf[1024];
278 : const struct units *next;
279 :
280 0 : for (next = u + 1; next->name && next->mult == u->mult; ++next)
281 : ;
282 :
283 0 : if (next->name) {
284 0 : for (u2 = next;
285 0 : u2->name && u->mult % u2->mult != 0;
286 0 : ++u2)
287 : ;
288 0 : if (u2->name == NULL)
289 0 : --u2;
290 0 : unparse_units (u->mult, u2, buf, sizeof(buf));
291 0 : fprintf (f, "1 %*s = %s\n", max_sz, u->name, buf);
292 : } else {
293 0 : fprintf (f, "1 %s\n", u->name);
294 : }
295 0 : u = next;
296 : }
297 0 : }
298 :
299 : static int
300 : print_flag (char *s, size_t len, int divisor, const char *name, int rem)
301 0 : {
302 0 : return snprintf (s, len, "%s%s", name, rem > 0 ? ", " : "");
303 : }
304 :
305 : static int
306 : update_flag (int in, unsigned mult)
307 0 : {
308 0 : return in - mult;
309 : }
310 :
311 : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
312 : unparse_flags (int num, const struct units *units, char *s, size_t len)
313 0 : {
314 0 : return unparse_something (num, units, s, len,
315 : print_flag,
316 : update_flag,
317 : "");
318 : }
319 :
320 : ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
321 : print_flags_table (const struct units *units, FILE *f)
322 0 : {
323 : const struct units *u;
324 :
325 0 : for(u = units; u->name; ++u)
326 0 : fprintf(f, "%s%s", u->name, (u+1)->name ? ", " : "\n");
327 0 : }
|
