In several standard headers, harmonize checks for legacy defines etc.
[dragonfly.git] / sys / libprop / prop_array_util.c
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 }