2 * Automated Testing Framework (atf)
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 #include "atf-c/error.h"
43 /* ---------------------------------------------------------------------
44 * Auxiliary functions.
45 * --------------------------------------------------------------------- */
49 resize(atf_dynstr_t *ad, size_t newsize)
54 PRE(newsize > ad->m_datasize);
56 newdata = (char *)malloc(newsize);
57 if (newdata == NULL) {
58 err = atf_no_memory_error();
60 strcpy(newdata, ad->m_data);
63 ad->m_datasize = newsize;
72 prepend_or_append(atf_dynstr_t *ad, const char *fmt, va_list ap,
81 err = atf_text_format_ap(&aux, fmt, ap2);
83 if (atf_is_error(err))
85 newlen = ad->m_length + strlen(aux);
87 if (newlen + sizeof(char) > ad->m_datasize) {
88 err = resize(ad, newlen + sizeof(char));
89 if (atf_is_error(err))
94 memmove(ad->m_data + strlen(aux), ad->m_data, ad->m_length + 1);
95 memcpy(ad->m_data, aux, strlen(aux));
97 strcpy(ad->m_data + ad->m_length, aux);
98 ad->m_length = newlen;
107 /* ---------------------------------------------------------------------
108 * The "atf_dynstr" type.
109 * --------------------------------------------------------------------- */
115 const size_t atf_dynstr_npos = SIZE_MAX;
118 * Constructors and destructors.
122 atf_dynstr_init(atf_dynstr_t *ad)
126 ad->m_data = (char *)malloc(sizeof(char));
127 if (ad->m_data == NULL) {
128 err = atf_no_memory_error();
132 ad->m_data[0] = '\0';
135 err = atf_no_error();
142 atf_dynstr_init_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
146 ad->m_datasize = strlen(fmt) + 1;
154 ad->m_data = (char *)malloc(ad->m_datasize);
155 if (ad->m_data == NULL) {
156 err = atf_no_memory_error();
161 ret = vsnprintf(ad->m_data, ad->m_datasize, fmt, ap2);
165 err = atf_libc_error(errno, "Cannot format string");
170 if ((size_t)ret >= ad->m_datasize) {
175 } while (ad->m_length >= ad->m_datasize);
177 err = atf_no_error();
179 POST(atf_is_error(err) || ad->m_data != NULL);
184 atf_dynstr_init_fmt(atf_dynstr_t *ad, const char *fmt, ...)
190 err = atf_dynstr_init_ap(ad, fmt, ap);
197 atf_dynstr_init_raw(atf_dynstr_t *ad, const void *mem, size_t memlen)
201 if (memlen >= SIZE_MAX - 1) {
202 err = atf_no_memory_error();
206 ad->m_data = (char *)malloc(memlen + 1);
207 if (ad->m_data == NULL) {
208 err = atf_no_memory_error();
212 ad->m_datasize = memlen + 1;
213 memcpy(ad->m_data, mem, memlen);
214 ad->m_data[memlen] = '\0';
215 ad->m_length = strlen(ad->m_data);
216 INV(ad->m_length <= memlen);
217 err = atf_no_error();
224 atf_dynstr_init_rep(atf_dynstr_t *ad, size_t len, char ch)
228 if (len == SIZE_MAX) {
229 err = atf_no_memory_error();
233 ad->m_datasize = (len + 1) * sizeof(char);
234 ad->m_data = (char *)malloc(ad->m_datasize);
235 if (ad->m_data == NULL) {
236 err = atf_no_memory_error();
240 memset(ad->m_data, ch, len);
241 ad->m_data[len] = '\0';
243 err = atf_no_error();
250 atf_dynstr_init_substr(atf_dynstr_t *ad, const atf_dynstr_t *src,
251 size_t beg, size_t end)
253 if (beg > src->m_length)
256 if (end == atf_dynstr_npos || end > src->m_length)
259 return atf_dynstr_init_raw(ad, src->m_data + beg, end - beg);
263 atf_dynstr_copy(atf_dynstr_t *dest, const atf_dynstr_t *src)
267 dest->m_data = (char *)malloc(src->m_datasize);
268 if (dest->m_data == NULL)
269 err = atf_no_memory_error();
271 memcpy(dest->m_data, src->m_data, src->m_datasize);
272 dest->m_datasize = src->m_datasize;
273 dest->m_length = src->m_length;
274 err = atf_no_error();
281 atf_dynstr_fini(atf_dynstr_t *ad)
283 INV(ad->m_data != NULL);
288 atf_dynstr_fini_disown(atf_dynstr_t *ad)
290 INV(ad->m_data != NULL);
299 atf_dynstr_cstring(const atf_dynstr_t *ad)
305 atf_dynstr_length(const atf_dynstr_t *ad)
311 atf_dynstr_rfind_ch(const atf_dynstr_t *ad, char ch)
315 for (pos = ad->m_length; pos > 0 && ad->m_data[pos - 1] != ch; pos--)
318 return pos == 0 ? atf_dynstr_npos : pos - 1;
326 atf_dynstr_append_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
332 err = prepend_or_append(ad, fmt, ap2, false);
339 atf_dynstr_append_fmt(atf_dynstr_t *ad, const char *fmt, ...)
345 err = prepend_or_append(ad, fmt, ap, false);
352 atf_dynstr_clear(atf_dynstr_t *ad)
354 ad->m_data[0] = '\0';
359 atf_dynstr_prepend_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
365 err = prepend_or_append(ad, fmt, ap2, true);
372 atf_dynstr_prepend_fmt(atf_dynstr_t *ad, const char *fmt, ...)
378 err = prepend_or_append(ad, fmt, ap, true);
389 atf_equal_dynstr_cstring(const atf_dynstr_t *ad, const char *str)
391 return strcmp(ad->m_data, str) == 0;
395 atf_equal_dynstr_dynstr(const atf_dynstr_t *s1, const atf_dynstr_t *s2)
397 return strcmp(s1->m_data, s2->m_data) == 0;