jim-array.c

   1
   2 /*
   3  * Implements the array command for jim
   4  *
   5  * (c) 2008 Steve Bennett <steveb@workware.net.au>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above
  14  *    copyright notice, this list of conditions and the following
  15  *    disclaimer in the documentation and/or other materials
  16  *    provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  21  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  22  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * The views and conclusions contained in the software and documentation
  32  * are those of the authors and should not be interpreted as representing
  33  * official policies, either expressed or implied, of the Jim Tcl Project.
  34  *
  35  * Based on code originally from Tcl 6.7:
  36  *
  37  * Copyright 1987-1991 Regents of the University of California
  38  * Permission to use, copy, modify, and distribute this
  39  * software and its documentation for any purpose and without
  40  * fee is hereby granted, provided that the above copyright
  41  * notice appear in all copies.  The University of California
  42  * makes no representations about the suitability of this
  43  * software for any purpose.  It is provided "as is" without
  44  * express or implied warranty.
  45  */
  46
  47 #include <limits.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <stdio.h>
  51 #include <errno.h>
  52
  53 #include <jim-subcmd.h>
  54
  55 static int array_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
  56 {
  57     /* Just a regular [info exists] */
  58     Jim_SetResultInt(interp, Jim_GetVariable(interp, argv[0], 0) != 0);
  59     return JIM_OK;
  60 }
  61
  62 static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
  63 {
  64     Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
  65
  66     if (!objPtr) {
  67         return JIM_OK;
  68     }
  69
  70     if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {
  71         /* Optimise the "all" case */
  72         if (Jim_IsList(objPtr)) {
  73             if (Jim_ListLength(interp, objPtr) % 2 != 0) {
  74                 /* A list with an odd number of elements */
  75                 return JIM_ERR;
  76             }
  77         }
  78         else if (Jim_DictSize(interp, objPtr) < 0) {
  79             /* Can't be converted to a dictionary */
  80             return JIM_ERR;
  81         }
  82         Jim_SetResult(interp, objPtr);
  83         return JIM_OK;
  84     }
  85
  86     /* Return a list of keys and values where the keys match the pattern */
  87     return Jim_DictValues(interp, objPtr, argv[1]);
  88 }
  89
  90 static int array_cmd_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
  91 {
  92     Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
  93
  94     if (!objPtr) {
  95         return JIM_OK;
  96     }
  97
  98     return Jim_DictKeys(interp, objPtr, argc == 1 ? NULL : argv[1]);
  99 }
 100
 101 static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 102 {
 103     int i;
 104     int len;
 105     Jim_Obj *resultObj;
 106     Jim_Obj *objPtr;
 107     Jim_Obj **dictValuesObj;
 108
 109     if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {
 110         /* Unset the whole array */
 111         Jim_UnsetVariable(interp, argv[0], JIM_NONE);
 112         return JIM_OK;
 113     }
 114
 115     objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
 116
 117     if (Jim_DictPairs(interp, objPtr, &dictValuesObj, &len) != JIM_OK) {
 118         return JIM_ERR;
 119     }
 120
 121     /* Create a new object with the values which don't match */
 122     resultObj = Jim_NewDictObj(interp, NULL, 0);
 123
 124     for (i = 0; i < len; i += 2) {
 125         if (!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0)) {
 126             Jim_DictAddElement(interp, resultObj, dictValuesObj[i], dictValuesObj[i + 1]);
 127         }
 128     }
 129     Jim_Free(dictValuesObj);
 130
 131     Jim_SetVariable(interp, argv[0], resultObj);
 132     return JIM_OK;
 133 }
 134
 135 static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 136 {
 137     Jim_Obj *objPtr;
 138     int len = 0;
 139
 140     /* Not found means zero length */
 141     objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
 142     if (objPtr) {
 143         len = Jim_DictSize(interp, objPtr);
 144         if (len < 0) {
 145             return JIM_ERR;
 146         }
 147     }
 148
 149     Jim_SetResultInt(interp, len);
 150
 151     return JIM_OK;
 152 }
 153
 154 static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 155 {
 156     int i;
 157     int len;
 158     Jim_Obj *listObj = argv[1];
 159     Jim_Obj *dictObj;
 160
 161     len = Jim_ListLength(interp, listObj);
 162     if (len % 2) {
 163         Jim_SetResultString(interp, "list must have an even number of elements", -1);
 164         return JIM_ERR;
 165     }
 166
 167     dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED);
 168     if (!dictObj) {
 169         /* Doesn't exist, so just set the list directly */
 170         return Jim_SetVariable(interp, argv[0], listObj);
 171     }
 172
 173     if (Jim_IsShared(dictObj)) {
 174         dictObj = Jim_DuplicateObj(interp, dictObj);
 175     }
 176
 177     for (i = 0; i < len; i += 2) {
 178         Jim_Obj *nameObj;
 179         Jim_Obj *valueObj;
 180
 181         Jim_ListIndex(interp, listObj, i, &nameObj, JIM_NONE);
 182         Jim_ListIndex(interp, listObj, i + 1, &valueObj, JIM_NONE);
 183
 184         Jim_DictAddElement(interp, dictObj, nameObj, valueObj);
 185     }
 186     return Jim_SetVariable(interp, argv[0], dictObj);
 187 }
 188
 189 static const jim_subcmd_type array_command_table[] = {
 190         {       "exists",
 191                 "arrayName",
 192                 array_cmd_exists,
 193                 1,
 194                 1,
 195                 /* Description: Does array exist? */
 196         },
 197         {       "get",
 198                 "arrayName ?pattern?",
 199                 array_cmd_get,
 200                 1,
 201                 2,
 202                 /* Description: Array contents as name value list */
 203         },
 204         {       "names",
 205                 "arrayName ?pattern?",
 206                 array_cmd_names,
 207                 1,
 208                 2,
 209                 /* Description: Array keys as a list */
 210         },
 211         {       "set",
 212                 "arrayName list",
 213                 array_cmd_set,
 214                 2,
 215                 2,
 216                 /* Description: Set array from list */
 217         },
 218         {       "size",
 219                 "arrayName",
 220                 array_cmd_size,
 221                 1,
 222                 1,
 223                 /* Description: Number of elements in array */
 224         },
 225         {       "unset",
 226                 "arrayName ?pattern?",
 227                 array_cmd_unset,
 228                 1,
 229                 2,
 230                 /* Description: Unset elements of an array */
 231         },
 232         {       NULL
 233         }
 234 };
 235
 236 int Jim_arrayInit(Jim_Interp *interp)
 237 {
 238     if (Jim_PackageProvide(interp, "array", "1.0", JIM_ERRMSG))
 239         return JIM_ERR;
 240
 241     Jim_CreateCommand(interp, "array", Jim_SubCmdProc, (void *)array_command_table, NULL);
 242     return JIM_OK;
 243 }