common/lib/libprop/prop_array_util.c

   1 /*      $NetBSD: prop_array_util.c,v 1.3 2011/03/24 17:05:39 bouyer Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2006 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Utility routines to make it more convenient to work with values
  34  * stored in array.
  35  *
  36  * Note: There is no special magic going on here.  We use the standard
  37  * proplib(3) APIs to do all of this work.  Any application could do
  38  * exactly what we're doing here.
  39  */
  40
  41 #include <prop/proplib.h>
  42 #include "prop_object_impl.h" /* hide kernel vs. not-kernel vs. standalone */
  43
  44 bool
  45 prop_array_get_bool(prop_array_t array,
  46                          unsigned int indx,
  47                          bool *valp)
  48 {
  49         prop_bool_t b;
  50
  51         b = prop_array_get(array, indx);
  52         if (prop_object_type(b) != PROP_TYPE_BOOL)
  53                 return (false);
  54
  55         *valp = prop_bool_true(b);
  56
  57         return (true);
  58 }
  59
  60 bool
  61 prop_array_set_bool(prop_array_t array,
  62                          unsigned int indx,
  63                          bool val)
  64 {
  65         prop_bool_t b;
  66         int rv;
  67
  68         b = prop_bool_create(val);
  69         if (b == NULL)
  70                 return (false);
  71         rv = prop_array_set(array, indx, b);
  72         prop_object_release(b);
  73
  74         return (rv);
  75 }
  76
  77 #define TEMPLATE(size)                                                  \
  78 bool                                                                    \
  79 prop_array_get_int ## size (prop_array_t array,                         \
  80                                  unsigned int indx,                     \
  81                                  int ## size ## _t *valp)               \
  82 {                                                                       \
  83         prop_number_t num;                                              \
  84                                                                         \
  85         num = prop_array_get(array, indx);                              \
  86         if (prop_object_type(num) != PROP_TYPE_NUMBER)                  \
  87                 return (false);                                         \
  88                                                                         \
  89         if (prop_number_unsigned(num) &&                                \
  90             prop_number_unsigned_integer_value(num) >                   \
  91            /*CONSTCOND*/((size) ==  8 ?  INT8_MAX :                     \
  92                          (size) == 16 ? INT16_MAX :                     \
  93                          (size) == 32 ? INT32_MAX : INT64_MAX)) {       \
  94                 return (false);                                         \
  95         }                                                               \
  96                                                                         \
  97         if (prop_number_size(num) > (size))                             \
  98                 return (false);                                         \
  99                                                                         \
 100         *valp = (int ## size ## _t) prop_number_integer_value(num);     \
 101                                                                         \
 102         return (true);                                                  \
 103 }                                                                       \
 104                                                                         \
 105 bool                                                                    \
 106 prop_array_get_uint ## size (prop_array_t array,                        \
 107                                   unsigned int indx,                    \
 108                                   uint ## size ## _t *valp)             \
 109 {                                                                       \
 110         prop_number_t num;                                              \
 111                                                                         \
 112         num = prop_array_get(array, indx);                              \
 113         if (prop_object_type(num) != PROP_TYPE_NUMBER)                  \
 114                 return (false);                                         \
 115                                                                         \
 116         if (prop_number_unsigned(num) == false &&                       \
 117             prop_number_integer_value(num) < 0) {                       \
 118                 return (false);                                         \
 119         }                                                               \
 120                                                                         \
 121         if (prop_number_size(num) > (size))                             \
 122                 return (false);                                         \
 123                                                                         \
 124         *valp = (uint ## size ## _t)                                    \
 125             prop_number_unsigned_integer_value(num);                    \
 126                                                                         \
 127         return (true);                                                  \
 128 }                                                                       \
 129                                                                         \
 130 bool                                                                    \
 131  prop_array_set_int ## size (prop_array_t array,                        \
 132                                  unsigned int indx,                     \
 133                                  int ## size ## _t val)                 \
 134 {                                                                       \
 135         prop_number_t num;                                              \
 136         int rv;                                                         \
 137                                                                         \
 138         num = prop_number_create_integer((int64_t) val);                \
 139         if (num == NULL)                                                \
 140                 return (false);                                         \
 141         rv = prop_array_set(array, indx, num);                          \
 142         prop_object_release(num);                                       \
 143                                                                         \
 144         return (rv);                                                    \
 145 }                                                                       \
 146                                                                         \
 147 bool                                                                    \
 148 prop_array_set_uint ## size (prop_array_t array,                        \
 149                                   unsigned int indx,                    \
 150                                   uint ## size ## _t val)               \
 151 {                                                                       \
 152         prop_number_t num;                                              \
 153         int rv;                                                         \
 154                                                                         \
 155         num = prop_number_create_unsigned_integer((uint64_t) val);      \
 156         if (num == NULL)                                                \
 157                 return (false);                                         \
 158         rv = prop_array_set(array, indx, num);                          \
 159         prop_object_release(num);                                       \
 160                                                                         \
 161         return (rv);                                                    \
 162 }                                                                       \
 163                                                                         \
 164 bool                                                                    \
 165 prop_array_add_int ## size (prop_array_t array,                         \
 166                                  int ## size ## _t val)                 \
 167 {                                                                       \
 168         prop_number_t num;                                              \
 169         int rv;                                                         \
 170                                                                         \
 171         num = prop_number_create_integer((int64_t) val);                \
 172         if (num == NULL)                                                \
 173                 return (false);                                         \
 174         rv = prop_array_add(array, num);                                \
 175         prop_object_release(num);                                       \
 176                                                                         \
 177         return (rv);                                                    \
 178 }                                                                       \
 179                                                                         \
 180 bool                                                                    \
 181 prop_array_add_uint ## size (prop_array_t array,                        \
 182                                   uint ## size ## _t val)               \
 183 {                                                                       \
 184         prop_number_t num;                                              \
 185         int rv;                                                         \
 186                                                                         \
 187         num = prop_number_create_integer((int64_t) val);                \
 188         if (num == NULL)                                                \
 189                 return (false);                                         \
 190         rv = prop_array_add(array, num);                                \
 191         prop_object_release(num);                                       \
 192                                                                         \
 193         return (rv);                                                    \
 194 }
 195
 196 TEMPLATE(8)
 197 TEMPLATE(16)
 198 TEMPLATE(32)
 199 TEMPLATE(64)
 200
 201 #undef TEMPLATE
 202
 203 #define TEMPLATE(variant, qualifier)                                    \
 204 bool                                                                    \
 205 prop_array_get_cstring ## variant (prop_array_t array,                  \
 206                                         unsigned int indx,              \
 207                                         qualifier char **cpp)           \
 208 {                                                                       \
 209         prop_string_t str;                                              \
 210                                                                         \
 211         str = prop_array_get(array, indx);                              \
 212         if (prop_object_type(str) != PROP_TYPE_STRING)                  \
 213                 return (false);                                         \
 214                                                                         \
 215         *cpp = prop_string_cstring ## variant (str);                    \
 216                                                                         \
 217         return (*cpp == NULL ? false : true);                           \
 218 }                                                                       \
 219                                                                         \
 220 bool                                                                    \
 221 prop_array_set_cstring ## variant (prop_array_t array,                  \
 222                                         unsigned int indx,              \
 223                                         const char *cp)                 \
 224 {                                                                       \
 225         prop_string_t str;                                              \
 226         int rv;                                                         \
 227                                                                         \
 228         str = prop_string_create_cstring ## variant (cp);               \
 229         if (str == NULL)                                                \
 230                 return (false);                                         \
 231         rv = prop_array_set(array, indx, str);                          \
 232         prop_object_release(str);                                       \
 233                                                                         \
 234         return (rv);                                                    \
 235 }
 236
 237 TEMPLATE(,)
 238 TEMPLATE(_nocopy,const)
 239
 240 #undef TEMPLATE
 241
 242 bool
 243 prop_array_add_and_rel(prop_array_t array, prop_object_t po)
 244 {
 245         bool ret;
 246         if (po == NULL)
 247                 return false;
 248         ret = prop_array_add(array, po);
 249         prop_object_release(po);
 250         return ret;
 251 }