The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/libprop/prop_array_util.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: prop_array_util.c,v 1.2 2008/09/11 13:15:13 haad 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 <libprop/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 }

Cache object: 1002df04baa54c87b4049b06658aa476


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.