src/helper/jim-nvp.c

   1 /* Jim - A small embeddable Tcl interpreter
   2  *
   3  * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
   4  * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
   5  * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net>
   6  * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
   7  * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
   8  * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
   9  * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
  10  * Copyright 2008 Steve Bennett <steveb@workware.net.au>
  11  * Copyright 2009 Nico Coesel <ncoesel@dealogic.nl>
  12  * Copyright 2009 Zachary T Welch zw@superlucidity.net
  13  * Copyright 2009 David Brownell
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  *
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above
  22  *    copyright notice, this list of conditions and the following
  23  *    disclaimer in the documentation and/or other materials
  24  *    provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  27  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  28  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  29  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  30  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  31  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  32  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  35  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  37  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  *
  39  * The views and conclusions contained in the software and documentation
  40  * are those of the authors and should not be interpreted as representing
  41  * official policies, either expressed or implied, of the Jim Tcl Project.
  42  */
  43
  44 #include <string.h>
  45 #include <jim-nvp.h>
  46
  47 int jim_get_nvp(Jim_Interp *interp,
  48         Jim_Obj *objptr, const struct jim_nvp *nvp_table, const struct jim_nvp **result)
  49 {
  50         struct jim_nvp *n;
  51         int e;
  52
  53         e = jim_nvp_name2value_obj(interp, nvp_table, objptr, &n);
  54         if (e == JIM_ERR)
  55                 return e;
  56
  57         /* Success? found? */
  58         if (n->name) {
  59                 /* remove const */
  60                 *result = (struct jim_nvp *)n;
  61                 return JIM_OK;
  62         } else
  63                 return JIM_ERR;
  64 }
  65
  66 struct jim_nvp *jim_nvp_name2value_simple(const struct jim_nvp *p, const char *name)
  67 {
  68         while (p->name) {
  69                 if (strcmp(name, p->name) == 0)
  70                         break;
  71                 p++;
  72         }
  73         return (struct jim_nvp *)p;
  74 }
  75
  76 struct jim_nvp *jim_nvp_name2value_nocase_simple(const struct jim_nvp *p, const char *name)
  77 {
  78         while (p->name) {
  79                 if (strcasecmp(name, p->name) == 0)
  80                         break;
  81                 p++;
  82         }
  83         return (struct jim_nvp *)p;
  84 }
  85
  86 int jim_nvp_name2value_obj(Jim_Interp *interp, const struct jim_nvp *p, Jim_Obj *o, struct jim_nvp **result)
  87 {
  88         return jim_nvp_name2value(interp, p, Jim_String(o), result);
  89 }
  90
  91 int jim_nvp_name2value(Jim_Interp *interp, const struct jim_nvp *_p, const char *name, struct jim_nvp **result)
  92 {
  93         const struct jim_nvp *p;
  94
  95         p = jim_nvp_name2value_simple(_p, name);
  96
  97         /* result */
  98         if (result)
  99                 *result = (struct jim_nvp *)p;
 100
 101         /* found? */
 102         if (p->name)
 103                 return JIM_OK;
 104         else
 105                 return JIM_ERR;
 106 }
 107
 108 int jim_nvp_name2value_obj_nocase(Jim_Interp *interp,
 109         const struct jim_nvp *p,
 110         Jim_Obj *o,
 111         struct jim_nvp **puthere)
 112 {
 113         return jim_nvp_name2value_nocase(interp, p, Jim_String(o), puthere);
 114 }
 115
 116 int jim_nvp_name2value_nocase(Jim_Interp *interp, const struct jim_nvp *_p, const char *name,
 117         struct jim_nvp **puthere)
 118 {
 119         const struct jim_nvp *p;
 120
 121         p = jim_nvp_name2value_nocase_simple(_p, name);
 122
 123         if (puthere)
 124                 *puthere = (struct jim_nvp *)p;
 125                                                 /* found */
 126         if (p->name)
 127                 return JIM_OK;
 128         else
 129                 return JIM_ERR;
 130 }
 131
 132 int jim_nvp_value2name_obj(Jim_Interp *interp, const struct jim_nvp *p, Jim_Obj *o, struct jim_nvp **result)
 133 {
 134         int e;
 135         jim_wide w;
 136
 137         e = Jim_GetWide(interp, o, &w);
 138         if (e != JIM_OK)
 139                 return e;
 140
 141         return jim_nvp_value2name(interp, p, w, result);
 142 }
 143
 144 struct jim_nvp *jim_nvp_value2name_simple(const struct jim_nvp *p, int value)
 145 {
 146         while (p->name) {
 147                 if (value == p->value)
 148                         break;
 149                 p++;
 150         }
 151         return (struct jim_nvp *)p;
 152 }
 153
 154 int jim_nvp_value2name(Jim_Interp *interp, const struct jim_nvp *_p, int value, struct jim_nvp **result)
 155 {
 156         const struct jim_nvp *p;
 157
 158         p = jim_nvp_value2name_simple(_p, value);
 159
 160         if (result)
 161                 *result = (struct jim_nvp *)p;
 162
 163         if (p->name)
 164                 return JIM_OK;
 165         else
 166                 return JIM_ERR;
 167 }
 168
 169 int jim_getopt_setup(struct jim_getopt_info *p, Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 170 {
 171         memset(p, 0, sizeof(*p));
 172         p->interp = interp;
 173         p->argc = argc;
 174         p->argv = argv;
 175
 176         return JIM_OK;
 177 }
 178
 179 void jim_getopt_debug(struct jim_getopt_info *p)
 180 {
 181         int x;
 182
 183         fprintf(stderr, "---args---\n");
 184         for (x = 0; x < p->argc; x++)
 185                 fprintf(stderr, "%2d) %s\n", x, Jim_String(p->argv[x]));
 186         fprintf(stderr, "-------\n");
 187 }
 188
 189 int jim_getopt_obj(struct jim_getopt_info *goi, Jim_Obj **puthere)
 190 {
 191         Jim_Obj *o;
 192
 193         o = NULL;               /* failure */
 194         if (goi->argc) {
 195                 /* success */
 196                 o = goi->argv[0];
 197                 goi->argc -= 1;
 198                 goi->argv += 1;
 199         }
 200         if (puthere)
 201                 *puthere = o;
 202         if (o)
 203                 return JIM_OK;
 204         else
 205                 return JIM_ERR;
 206 }
 207
 208 int jim_getopt_string(struct jim_getopt_info *goi, const char **puthere, int *len)
 209 {
 210         int r;
 211         Jim_Obj *o;
 212         const char *cp;
 213
 214         r = jim_getopt_obj(goi, &o);
 215         if (r == JIM_OK) {
 216                 cp = Jim_GetString(o, len);
 217                 if (puthere) {
 218                         *puthere = cp;
 219                 }
 220         }
 221         return r;
 222 }
 223
 224 int jim_getopt_double(struct jim_getopt_info *goi, double *puthere)
 225 {
 226         int r;
 227         Jim_Obj *o;
 228         double _safe;
 229
 230         if (!puthere)
 231                 puthere = &_safe;
 232
 233         r = jim_getopt_obj(goi, &o);
 234         if (r == JIM_OK) {
 235                 r = Jim_GetDouble(goi->interp, o, puthere);
 236                 if (r != JIM_OK)
 237                         Jim_SetResultFormatted(goi->interp, "not a number: %#s", o);
 238         }
 239         return r;
 240 }
 241
 242 int jim_getopt_wide(struct jim_getopt_info *goi, jim_wide *puthere)
 243 {
 244         int r;
 245         Jim_Obj *o;
 246         jim_wide _safe;
 247
 248         if (!puthere)
 249                 puthere = &_safe;
 250
 251         r = jim_getopt_obj(goi, &o);
 252         if (r == JIM_OK)
 253                 r = Jim_GetWide(goi->interp, o, puthere);
 254         return r;
 255 }
 256
 257 int jim_getopt_nvp(struct jim_getopt_info *goi, const struct jim_nvp *nvp, struct jim_nvp **puthere)
 258 {
 259         struct jim_nvp *_safe;
 260         Jim_Obj *o;
 261         int e;
 262
 263         if (!puthere)
 264                 puthere = &_safe;
 265
 266         e = jim_getopt_obj(goi, &o);
 267         if (e == JIM_OK)
 268                 e = jim_nvp_name2value_obj(goi->interp, nvp, o, puthere);
 269
 270         return e;
 271 }
 272
 273 void jim_getopt_nvp_unknown(struct jim_getopt_info *goi, const struct jim_nvp *nvptable, int hadprefix)
 274 {
 275         if (hadprefix)
 276                 jim_set_result_nvp_unknown(goi->interp, goi->argv[-2], goi->argv[-1], nvptable);
 277         else
 278                 jim_set_result_nvp_unknown(goi->interp, NULL, goi->argv[-1], nvptable);
 279 }
 280
 281 int jim_getopt_enum(struct jim_getopt_info *goi, const char *const *lookup, int *puthere)
 282 {
 283         int _safe;
 284         Jim_Obj *o;
 285         int e;
 286
 287         if (!puthere)
 288                 puthere = &_safe;
 289         e = jim_getopt_obj(goi, &o);
 290         if (e == JIM_OK)
 291                 e = Jim_GetEnum(goi->interp, o, lookup, puthere, "option", JIM_ERRMSG);
 292         return e;
 293 }
 294
 295 void jim_set_result_nvp_unknown(Jim_Interp *interp,
 296         Jim_Obj *param_name, Jim_Obj *param_value, const struct jim_nvp *nvp)
 297 {
 298         if (param_name)
 299                 Jim_SetResultFormatted(interp,
 300                         "%#s: Unknown: %#s, try one of: ",
 301                         param_name,
 302                         param_value);
 303         else
 304                 Jim_SetResultFormatted(interp, "Unknown param: %#s, try one of: ", param_value);
 305         while (nvp->name) {
 306                 const char *a;
 307                 const char *b;
 308
 309                 if ((nvp + 1)->name) {
 310                         a = nvp->name;
 311                         b = ", ";
 312                 } else {
 313                         a = "or ";
 314                         b = nvp->name;
 315                 }
 316                 Jim_AppendStrings(interp, Jim_GetResult(interp), a, b, NULL);
 317                 nvp++;
 318         }
 319 }
 320
 321 const char *jim_debug_argv_string(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 322 {
 323         static Jim_Obj *debug_string_obj;
 324
 325         int x;
 326
 327         if (debug_string_obj)
 328                 Jim_FreeObj(interp, debug_string_obj);
 329
 330         debug_string_obj = Jim_NewEmptyStringObj(interp);
 331         for (x = 0; x < argc; x++)
 332                 Jim_AppendStrings(interp, debug_string_obj, Jim_String(argv[x]), " ", NULL);
 333
 334         return Jim_String(debug_string_obj);
 335 }