lib/roken/parse_units.c

   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$");
  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 }