1 /* $NetBSD: prop_array.c,v 1.20 2008/08/11 05:54:21 christos Exp $ */
4 * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
7 * This code is derived from software contributed to The NetBSD Foundation
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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.
32 #include <libprop/prop_array.h>
33 #include "prop_object_impl.h"
35 #if !defined(_KERNEL) && !defined(_STANDALONE)
40 struct _prop_object pa_obj;
41 _PROP_RWLOCK_DECL(pa_rwlock)
42 prop_object_t * pa_array;
43 unsigned int pa_capacity;
44 unsigned int pa_count;
50 #define PA_F_IMMUTABLE 0x01 /* array is immutable */
52 _PROP_POOL_INIT(_prop_array_pool, sizeof(struct _prop_array), "proparay")
53 _PROP_MALLOC_DEFINE(M_PROP_ARRAY, "prop array",
54 "property array container object")
56 static _prop_object_free_rv_t
57 _prop_array_free(prop_stack_t, prop_object_t *);
58 static void _prop_array_emergency_free(prop_object_t);
59 static bool _prop_array_externalize(
60 struct _prop_object_externalize_context *,
62 static _prop_object_equals_rv_t
63 _prop_array_equals(prop_object_t, prop_object_t,
65 prop_object_t *, prop_object_t *);
66 static void _prop_array_equals_finish(prop_object_t, prop_object_t);
67 static prop_object_iterator_t
68 _prop_array_iterator_locked(prop_array_t);
70 _prop_array_iterator_next_object_locked(void *);
71 static void _prop_array_iterator_reset_locked(void *);
73 static const struct _prop_object_type _prop_object_type_array = {
74 .pot_type = PROP_TYPE_ARRAY,
75 .pot_free = _prop_array_free,
76 .pot_emergency_free = _prop_array_emergency_free,
77 .pot_extern = _prop_array_externalize,
78 .pot_equals = _prop_array_equals,
79 .pot_equals_finish = _prop_array_equals_finish,
82 #define prop_object_is_array(x) \
83 ((x) != NULL && (x)->pa_obj.po_type == &_prop_object_type_array)
85 #define prop_array_is_immutable(x) (((x)->pa_flags & PA_F_IMMUTABLE) != 0)
87 struct _prop_array_iterator {
88 struct _prop_object_iterator pai_base;
89 unsigned int pai_index;
92 #define EXPAND_STEP 16
94 static _prop_object_free_rv_t
95 _prop_array_free(prop_stack_t stack, prop_object_t *obj)
97 prop_array_t pa = *obj;
100 _PROP_ASSERT(pa->pa_count <= pa->pa_capacity);
101 _PROP_ASSERT((pa->pa_capacity == 0 && pa->pa_array == NULL) ||
102 (pa->pa_capacity != 0 && pa->pa_array != NULL));
104 /* The easy case is an empty array, just free and return. */
105 if (pa->pa_count == 0) {
106 if (pa->pa_array != NULL)
107 _PROP_FREE(pa->pa_array, M_PROP_ARRAY);
109 _PROP_RWLOCK_DESTROY(pa->pa_rwlock);
111 _PROP_POOL_PUT(_prop_array_pool, pa);
113 return (_PROP_OBJECT_FREE_DONE);
116 po = pa->pa_array[pa->pa_count - 1];
117 _PROP_ASSERT(po != NULL);
121 * If we are in emergency release mode,
122 * just let caller recurse down.
125 return (_PROP_OBJECT_FREE_FAILED);
128 /* Otherwise, try to push the current object on the stack. */
129 if (!_prop_stack_push(stack, pa, NULL, NULL, NULL)) {
130 /* Push failed, entering emergency release mode. */
131 return (_PROP_OBJECT_FREE_FAILED);
133 /* Object pushed on stack, caller will release it. */
136 return (_PROP_OBJECT_FREE_RECURSE);
140 _prop_array_emergency_free(prop_object_t obj)
142 prop_array_t pa = obj;
144 _PROP_ASSERT(pa->pa_count != 0);
149 _prop_array_externalize(struct _prop_object_externalize_context *ctx,
153 struct _prop_object *po;
154 prop_object_iterator_t pi;
158 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
160 if (pa->pa_count == 0) {
161 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
162 return (_prop_object_externalize_empty_tag(ctx, "array"));
165 /* XXXJRT Hint "count" for the internalize step? */
166 if (_prop_object_externalize_start_tag(ctx, "array") == false ||
167 _prop_object_externalize_append_char(ctx, '\n') == false)
170 pi = _prop_array_iterator_locked(pa);
175 _PROP_ASSERT(ctx->poec_depth != 0);
177 while ((po = _prop_array_iterator_next_object_locked(pi)) != NULL) {
178 if ((*po->po_type->pot_extern)(ctx, po) == false) {
179 prop_object_iterator_release(pi);
184 prop_object_iterator_release(pi);
187 for (i = 0; i < ctx->poec_depth; i++) {
188 if (_prop_object_externalize_append_char(ctx, '\t') == false)
191 if (_prop_object_externalize_end_tag(ctx, "array") == false)
197 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
202 static _prop_object_equals_rv_t
203 _prop_array_equals(prop_object_t v1, prop_object_t v2,
204 void **stored_pointer1, void **stored_pointer2,
205 prop_object_t *next_obj1, prop_object_t *next_obj2)
207 prop_array_t array1 = v1;
208 prop_array_t array2 = v2;
210 _prop_object_equals_rv_t rv = _PROP_OBJECT_EQUALS_FALSE;
212 if (array1 == array2)
213 return (_PROP_OBJECT_EQUALS_TRUE);
215 _PROP_ASSERT(*stored_pointer1 == *stored_pointer2);
216 idx = (uintptr_t)*stored_pointer1;
218 /* For the first iteration, lock the objects. */
220 if ((uintptr_t)array1 < (uintptr_t)array2) {
221 _PROP_RWLOCK_RDLOCK(array1->pa_rwlock);
222 _PROP_RWLOCK_RDLOCK(array2->pa_rwlock);
224 _PROP_RWLOCK_RDLOCK(array2->pa_rwlock);
225 _PROP_RWLOCK_RDLOCK(array1->pa_rwlock);
229 if (array1->pa_count != array2->pa_count)
231 if (idx == array1->pa_count) {
232 rv = _PROP_OBJECT_EQUALS_TRUE;
235 _PROP_ASSERT(idx < array1->pa_count);
237 *stored_pointer1 = (void *)(idx + 1);
238 *stored_pointer2 = (void *)(idx + 1);
240 *next_obj1 = array1->pa_array[idx];
241 *next_obj2 = array2->pa_array[idx];
243 return (_PROP_OBJECT_EQUALS_RECURSE);
246 _PROP_RWLOCK_UNLOCK(array1->pa_rwlock);
247 _PROP_RWLOCK_UNLOCK(array2->pa_rwlock);
252 _prop_array_equals_finish(prop_object_t v1, prop_object_t v2)
254 _PROP_RWLOCK_UNLOCK(((prop_array_t)v1)->pa_rwlock);
255 _PROP_RWLOCK_UNLOCK(((prop_array_t)v2)->pa_rwlock);
259 _prop_array_alloc(unsigned int capacity)
262 prop_object_t *array;
265 array = _PROP_CALLOC(capacity * sizeof(prop_object_t),
272 pa = _PROP_POOL_GET(_prop_array_pool);
274 _prop_object_init(&pa->pa_obj, &_prop_object_type_array);
275 pa->pa_obj.po_type = &_prop_object_type_array;
277 _PROP_RWLOCK_INIT(pa->pa_rwlock);
278 pa->pa_array = array;
279 pa->pa_capacity = capacity;
284 } else if (array != NULL)
285 _PROP_FREE(array, M_PROP_ARRAY);
291 _prop_array_expand(prop_array_t pa, unsigned int capacity)
293 prop_object_t *array, *oarray;
296 * Array must be WRITE-LOCKED.
299 oarray = pa->pa_array;
301 array = _PROP_CALLOC(capacity * sizeof(*array), M_PROP_ARRAY);
305 memcpy(array, oarray, pa->pa_capacity * sizeof(*array));
306 pa->pa_array = array;
307 pa->pa_capacity = capacity;
310 _PROP_FREE(oarray, M_PROP_ARRAY);
316 _prop_array_iterator_next_object_locked(void *v)
318 struct _prop_array_iterator *pai = v;
319 prop_array_t pa = pai->pai_base.pi_obj;
320 prop_object_t po = NULL;
322 _PROP_ASSERT(prop_object_is_array(pa));
324 if (pa->pa_version != pai->pai_base.pi_version)
325 goto out; /* array changed during iteration */
327 _PROP_ASSERT(pai->pai_index <= pa->pa_count);
329 if (pai->pai_index == pa->pa_count)
330 goto out; /* we've iterated all objects */
332 po = pa->pa_array[pai->pai_index];
340 _prop_array_iterator_next_object(void *v)
342 struct _prop_array_iterator *pai = v;
343 prop_array_t pa __unused = pai->pai_base.pi_obj;
346 _PROP_ASSERT(prop_object_is_array(pa));
348 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
349 po = _prop_array_iterator_next_object_locked(pai);
350 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
355 _prop_array_iterator_reset_locked(void *v)
357 struct _prop_array_iterator *pai = v;
358 prop_array_t pa = pai->pai_base.pi_obj;
360 _PROP_ASSERT(prop_object_is_array(pa));
363 pai->pai_base.pi_version = pa->pa_version;
367 _prop_array_iterator_reset(void *v)
369 struct _prop_array_iterator *pai = v;
370 prop_array_t pa __unused = pai->pai_base.pi_obj;
372 _PROP_ASSERT(prop_object_is_array(pa));
374 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
375 _prop_array_iterator_reset_locked(pai);
376 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
380 * prop_array_create --
381 * Create an empty array.
384 prop_array_create(void)
387 return (_prop_array_alloc(0));
391 * prop_array_create_with_capacity --
392 * Create an array with the capacity to store N objects.
395 prop_array_create_with_capacity(unsigned int capacity)
398 return (_prop_array_alloc(capacity));
403 * Copy an array. The new array has an initial capacity equal to
404 * the number of objects stored in the original array. The new
405 * array contains references to the original array's objects, not
406 * copies of those objects (i.e. a shallow copy).
409 prop_array_copy(prop_array_t opa)
415 if (! prop_object_is_array(opa))
418 _PROP_RWLOCK_RDLOCK(opa->pa_rwlock);
420 pa = _prop_array_alloc(opa->pa_count);
422 for (idx = 0; idx < opa->pa_count; idx++) {
423 po = opa->pa_array[idx];
424 prop_object_retain(po);
425 pa->pa_array[idx] = po;
427 pa->pa_count = opa->pa_count;
428 pa->pa_flags = opa->pa_flags;
430 _PROP_RWLOCK_UNLOCK(opa->pa_rwlock);
435 * prop_array_copy_mutable --
436 * Like prop_array_copy(), but the resulting array is mutable.
439 prop_array_copy_mutable(prop_array_t opa)
443 pa = prop_array_copy(opa);
445 pa->pa_flags &= ~PA_F_IMMUTABLE;
451 * prop_array_capacity --
452 * Return the capacity of the array.
455 prop_array_capacity(prop_array_t pa)
459 if (! prop_object_is_array(pa))
462 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
463 rv = pa->pa_capacity;
464 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
470 * prop_array_count --
471 * Return the number of objects stored in the array.
474 prop_array_count(prop_array_t pa)
478 if (! prop_object_is_array(pa))
481 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
483 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
489 * prop_array_ensure_capacity --
490 * Ensure that the array has the capacity to store the specified
491 * total number of objects (inluding the objects already stored
495 prop_array_ensure_capacity(prop_array_t pa, unsigned int capacity)
499 if (! prop_object_is_array(pa))
502 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
503 if (capacity > pa->pa_capacity)
504 rv = _prop_array_expand(pa, capacity);
507 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
512 static prop_object_iterator_t
513 _prop_array_iterator_locked(prop_array_t pa)
515 struct _prop_array_iterator *pai;
517 if (! prop_object_is_array(pa))
520 pai = _PROP_CALLOC(sizeof(*pai), M_TEMP);
523 pai->pai_base.pi_next_object = _prop_array_iterator_next_object;
524 pai->pai_base.pi_reset = _prop_array_iterator_reset;
525 prop_object_retain(pa);
526 pai->pai_base.pi_obj = pa;
527 _prop_array_iterator_reset_locked(pai);
529 return (&pai->pai_base);
533 * prop_array_iterator --
534 * Return an iterator for the array. The array is retained by
537 prop_object_iterator_t
538 prop_array_iterator(prop_array_t pa)
540 prop_object_iterator_t pi;
542 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
543 pi = _prop_array_iterator_locked(pa);
544 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
549 * prop_array_make_immutable --
550 * Make the array immutable.
553 prop_array_make_immutable(prop_array_t pa)
556 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
557 if (prop_array_is_immutable(pa) == false)
558 pa->pa_flags |= PA_F_IMMUTABLE;
559 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
563 * prop_array_mutable --
564 * Returns true if the array is mutable.
567 prop_array_mutable(prop_array_t pa)
571 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
572 rv = prop_array_is_immutable(pa) == false;
573 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
580 * Return the object stored at the specified array index.
583 prop_array_get(prop_array_t pa, unsigned int idx)
585 prop_object_t po = NULL;
587 if (! prop_object_is_array(pa))
590 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
591 if (idx >= pa->pa_count)
593 po = pa->pa_array[idx];
594 _PROP_ASSERT(po != NULL);
596 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
601 _prop_array_add(prop_array_t pa, prop_object_t po)
605 * Array must be WRITE-LOCKED.
608 _PROP_ASSERT(pa->pa_count <= pa->pa_capacity);
610 if (prop_array_is_immutable(pa) ||
611 (pa->pa_count == pa->pa_capacity &&
612 _prop_array_expand(pa, pa->pa_capacity + EXPAND_STEP) == false))
615 prop_object_retain(po);
616 pa->pa_array[pa->pa_count++] = po;
624 * Store a reference to an object at the specified array index.
625 * This method is not allowed to create holes in the array; the
626 * caller must either be setting the object just beyond the existing
627 * count or replacing an already existing object reference.
630 prop_array_set(prop_array_t pa, unsigned int idx, prop_object_t po)
635 if (! prop_object_is_array(pa))
638 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
640 if (prop_array_is_immutable(pa))
643 if (idx == pa->pa_count) {
644 rv = _prop_array_add(pa, po);
648 _PROP_ASSERT(idx < pa->pa_count);
650 opo = pa->pa_array[idx];
651 _PROP_ASSERT(opo != NULL);
653 prop_object_retain(po);
654 pa->pa_array[idx] = po;
657 prop_object_release(opo);
662 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
668 * Add a reference to an object to the specified array, appending
669 * to the end and growing the array's capacity, if necessary.
672 prop_array_add(prop_array_t pa, prop_object_t po)
676 if (! prop_object_is_array(pa))
679 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
680 rv = _prop_array_add(pa, po);
681 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
687 * prop_array_remove --
688 * Remove the reference to an object from an array at the specified
689 * index. The array will be compacted following the removal.
692 prop_array_remove(prop_array_t pa, unsigned int idx)
696 if (! prop_object_is_array(pa))
699 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
701 _PROP_ASSERT(idx < pa->pa_count);
703 /* XXX Should this be a _PROP_ASSERT()? */
704 if (prop_array_is_immutable(pa)) {
705 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
709 po = pa->pa_array[idx];
710 _PROP_ASSERT(po != NULL);
712 for (++idx; idx < pa->pa_count; idx++)
713 pa->pa_array[idx - 1] = pa->pa_array[idx];
717 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
719 prop_object_release(po);
723 * prop_array_equals --
724 * Return true if the two arrays are equivalent. Note we do a
725 * by-value comparison of the objects in the array.
728 prop_array_equals(prop_array_t array1, prop_array_t array2)
730 if (!prop_object_is_array(array1) || !prop_object_is_array(array2))
733 return (prop_object_equals(array1, array2));
737 * prop_array_externalize --
738 * Externalize an array, return a NUL-terminated buffer
739 * containing the XML-style representation. The buffer is allocated
740 * with the M_TEMP memory type.
743 prop_array_externalize(prop_array_t pa)
745 struct _prop_object_externalize_context *ctx;
748 ctx = _prop_object_externalize_context_alloc();
752 if (_prop_object_externalize_header(ctx) == false ||
753 (*pa->pa_obj.po_type->pot_extern)(ctx, pa) == false ||
754 _prop_object_externalize_footer(ctx) == false) {
755 /* We are responsible for releasing the buffer. */
756 _PROP_FREE(ctx->poec_buf, M_TEMP);
757 _prop_object_externalize_context_free(ctx);
762 _prop_object_externalize_context_free(ctx);
768 * _prop_array_internalize --
769 * Parse an <array>...</array> and return the object created from the
770 * external representation.
772 static bool _prop_array_internalize_body(prop_stack_t, prop_object_t *,
773 struct _prop_object_internalize_context *);
776 _prop_array_internalize(prop_stack_t stack, prop_object_t *obj,
777 struct _prop_object_internalize_context *ctx)
779 /* We don't currently understand any attributes. */
780 if (ctx->poic_tagattr != NULL)
783 *obj = prop_array_create();
785 * We are done if the create failed or no child elements exist.
787 if (*obj == NULL || ctx->poic_is_empty_element)
791 * Opening tag is found, now continue to the first element.
793 return (_prop_array_internalize_body(stack, obj, ctx));
797 _prop_array_internalize_continue(prop_stack_t stack,
799 struct _prop_object_internalize_context *ctx,
800 void *data, prop_object_t child)
804 _PROP_ASSERT(data == NULL);
807 goto bad; /* Element could not be parsed. */
811 if (prop_array_add(array, child) == false) {
812 prop_object_release(child);
815 prop_object_release(child);
818 * Current element is processed and added, look for next.
820 return (_prop_array_internalize_body(stack, obj, ctx));
823 prop_object_release(*obj);
829 _prop_array_internalize_body(prop_stack_t stack, prop_object_t *obj,
830 struct _prop_object_internalize_context *ctx)
832 prop_array_t array = *obj;
834 _PROP_ASSERT(array != NULL);
836 /* Fetch the next tag. */
837 if (_prop_object_internalize_find_tag(ctx, NULL,
838 _PROP_TAG_TYPE_EITHER) == false)
841 /* Check to see if this is the end of the array. */
842 if (_PROP_TAG_MATCH(ctx, "array") &&
843 ctx->poic_tag_type == _PROP_TAG_TYPE_END) {
844 /* It is, so don't iterate any further. */
848 if (_prop_stack_push(stack, array,
849 _prop_array_internalize_continue, NULL, NULL))
853 prop_object_release(array);
859 * prop_array_internalize --
860 * Create an array by parsing the XML-style representation.
863 prop_array_internalize(const char *xml)
865 return _prop_generic_internalize(xml, "array");
868 #if !defined(_KERNEL) && !defined(_STANDALONE)
870 * prop_array_externalize_to_file --
871 * Externalize an array to the specified file.
874 prop_array_externalize_to_file(prop_array_t array, const char *fname)
878 int save_errno = 0; /* XXXGCC -Wuninitialized [mips, ...] */
880 xml = prop_array_externalize(array);
883 rv = _prop_object_externalize_write_file(fname, xml, strlen(xml));
886 _PROP_FREE(xml, M_TEMP);
894 * prop_array_internalize_from_file --
895 * Internalize an array from a file.
898 prop_array_internalize_from_file(const char *fname)
900 struct _prop_object_internalize_mapped_file *mf;
903 mf = _prop_object_internalize_map_file(fname);
906 array = prop_array_internalize(mf->poimf_xml);
907 _prop_object_internalize_unmap_file(mf);
911 #endif /* _KERNEL && !_STANDALONE */