Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/lex/buf.c	Lines:	60	92	65.2 %
Date:	2017-11-13	Branches:	12	28	42.9 %


/* $OpenBSD: buf.c,v 1.7 2015/11/20 18:54:49 tedu Exp $ */

/* flex - tool to generate fast lexical analyzers */

/*  Copyright (c) 1990 The Regents of the University of California. */
/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */
/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */
/*  to contract no. DE-AC03-76SF00098 between the United States */
/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */
/*  modification, are permitted provided that the following conditions */
/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */
/*     notice, this list of conditions and the following disclaimer. */
/*  2. Redistributions in binary form must reproduce the above copyright */
/*     notice, this list of conditions and the following disclaimer in the */
/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */
/*  may be used to endorse or promote products derived from this software */
/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/*  PURPOSE. */


#include "flexdef.h"

/* Take note: The buffer object is sometimes used as a String buffer (one
 * continuous string), and sometimes used as a list of strings, usually line by
 * line.
 *
 * The type is specified in buf_init by the elt_size. If the elt_size is
 * sizeof(char), then the buffer should be treated as string buffer. If the
 * elt_size is sizeof(char*), then the buffer should be treated as a list of
 * strings.
 *
 * Certain functions are only appropriate for one type or the other.
 */

/* global buffers. */
struct Buf userdef_buf;		/**< for user #definitions triggered by cmd-line. */
struct Buf defs_buf;		/**< for #define's autogenerated. List of strings. */
struct Buf yydmap_buf;		/**< string buffer to hold yydmap elements */
struct Buf m4defs_buf;		/**< m4 definitions. List of strings. */
struct Buf top_buf;		/**< contains %top code. String buffer. */

struct Buf *
buf_print_strings(struct Buf * buf, FILE * out)
{
	int i;

	if (!buf || !out)
		return buf;

	for (i = 0; i < buf->nelts; i++) {
		const char *s = ((char **) buf->elts)[i];
		if (s)
			fprintf(out, "%s", s);
	}
	return buf;
}

/* Append a "%s" formatted string to a string buffer */
struct Buf *
buf_prints(struct Buf * buf, const char *fmt, const char *s)
{
	char *t;
	size_t tsz;

	tsz = strlen(fmt) + strlen(s) + 1;
	t = malloc(tsz);
	if (!t)
		flexfatal(_("Allocation of buffer to print string failed"));
	snprintf(t, tsz, fmt, s);
	buf = buf_strappend(buf, t);
	free(t);
	return buf;
}

/** Append a line directive to the string buffer.
 * @param buf A string buffer.
 * @param filename file name
 * @param lineno line number
 * @return buf
 */
struct Buf *
buf_linedir(struct Buf * buf, const char *filename, int lineno)
{
	const char *src;
	char *dst, *t;
	size_t tsz;

	tsz = strlen("#line \"\"\n") +	/* constant parts */
	    2 * strlen(filename) +	/* filename with possibly all backslashes escaped */
	    (int) (1 + log10(abs(lineno))) +	/* line number */
	    1;			/* NUL */
	t = malloc(tsz);
	if (!t)
		flexfatal(_("Allocation of buffer for line directive failed"));
	dst = t + snprintf(t, tsz, "#line %d \"", lineno);
	for (src = filename; *src; *dst++ = *src++)
		if (*src == '\\')	/* escape backslashes */
			*dst++ = '\\';
	*dst++ = '"';
	*dst++ = '\n';
	*dst = '\0';
	buf = buf_strappend(buf, t);
	free(t);
	return buf;
}


/** Append the contents of @a src to @a dest.
 * @param @a dest the destination buffer
 * @param @a dest the source buffer
 * @return @a dest
 */
struct Buf *
buf_concat(struct Buf * dest, const struct Buf * src)
{
	buf_append(dest, src->elts, src->nelts);
	return dest;
}


/* Appends n characters in str to buf. */
struct Buf *
buf_strnappend(struct Buf *buf, const char *str, int n)
{
	buf_append(buf, str, n + 1);

	/* "undo" the '\0' character that buf_append() already copied. */
	buf->nelts--;

	return buf;
}

/* Appends characters in str to buf. */
struct Buf *
buf_strappend(struct Buf *buf, const char *str)
{
	return buf_strnappend(buf, str, strlen(str));
}

/* appends "#define str def\n" */
struct Buf *
buf_strdefine(struct Buf *buf, const char *str, const char *def)
{
	buf_strappend(buf, "#define ");
	buf_strappend(buf, " ");
	buf_strappend(buf, str);
	buf_strappend(buf, " ");
	buf_strappend(buf, def);
	buf_strappend(buf, "\n");
	return buf;
}

/** Pushes "m4_define( [[def]], [[val]])m4_dnl" to end of buffer.
 * @param buf A buffer as a list of strings.
 * @param def The m4 symbol to define.
 * @param val The definition; may be NULL.
 * @return buf
 */
struct Buf *
buf_m4_define(struct Buf * buf, const char *def, const char *val)
{
	const char *fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
	char *str;
	size_t strsz;

	val = val ? val : "";
	strsz = strlen(fmt) + strlen(def) + strlen(val) + 2;
	str = malloc(strsz);
	if (!str)
		flexfatal(_("Allocation of buffer for m4 def failed"));

	snprintf(str, strsz, fmt, def, val);
	buf_append(buf, &str, 1);
	return buf;
}

/** Pushes "m4_undefine([[def]])m4_dnl" to end of buffer.
 * @param buf A buffer as a list of strings.
 * @param def The m4 symbol to undefine.
 * @return buf
 */
struct Buf *
buf_m4_undefine(struct Buf * buf, const char *def)
{
	const char *fmt = "m4_undefine( [[%s]])m4_dnl\n";
	char *str;
	size_t strsz;

	strsz = strlen(fmt) + strlen(def) + 2;
	str = malloc(strsz);
	if (!str)
		flexfatal(_("Allocation of buffer for m4 undef failed"));

	snprintf(str, strsz, fmt, def);
	buf_append(buf, &str, 1);
	return buf;
}

/* create buf with 0 elements, each of size elem_size. */
void
buf_init(struct Buf *buf, size_t elem_size)
{
	buf->elts = NULL;
	buf->nelts = 0;
	buf->elt_size = elem_size;
	buf->nmax = 0;
}

/* frees memory */
void
buf_destroy(struct Buf *buf)
{
	free(buf->elts);
	buf->elts = NULL;
}


/* appends ptr[] to buf, grow if necessary.
 * n_elem is number of elements in ptr[], NOT bytes.
 * returns buf.
 * We grow by mod(512) boundaries.
 */

struct Buf *
buf_append(struct Buf *buf, const void *ptr, int n_elem)
{
	int n_alloc = 0;

	if (!ptr || n_elem == 0)
		return buf;

	/* May need to alloc more. */
	if (n_elem + buf->nelts > buf->nmax) {

		/* exact amount needed... */
		n_alloc = (n_elem + buf->nelts) * buf->elt_size;

		/* ...plus some extra */
		if (((n_alloc * buf->elt_size) % 512) != 0
		    && buf->elt_size < 512)
			n_alloc +=
			    (512 -
			    ((n_alloc * buf->elt_size) % 512)) /
			    buf->elt_size;

		if (!buf->elts)
			buf->elts =
			    allocate_array(n_alloc, buf->elt_size);
		else
			buf->elts =
			    reallocate_array(buf->elts, n_alloc,
			    buf->elt_size);

		buf->nmax = n_alloc;
	}
	memcpy((char *) buf->elts + buf->nelts * buf->elt_size, ptr,
	    n_elem * buf->elt_size);
	buf->nelts += n_elem;

	return buf;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: buf.c,v 1.7 2015/11/20 18:54:49 tedu Exp $ */
2
3			/* flex - tool to generate fast lexical analyzers */
4
5			/* Copyright (c) 1990 The Regents of the University of California. */
6			/* All rights reserved. */
7
8			/* This code is derived from software contributed to Berkeley by */
9			/* Vern Paxson. */
10
11			/* The United States Government has rights in this work pursuant */
12			/* to contract no. DE-AC03-76SF00098 between the United States */
13			/* Department of Energy and the University of California. */
14
15			/* This file is part of flex. */
16
17			/* Redistribution and use in source and binary forms, with or without */
18			/* modification, are permitted provided that the following conditions */
19			/* are met: */
20
21			/* 1. Redistributions of source code must retain the above copyright */
22			/* notice, this list of conditions and the following disclaimer. */
23			/* 2. Redistributions in binary form must reproduce the above copyright */
24			/* notice, this list of conditions and the following disclaimer in the */
25			/* documentation and/or other materials provided with the distribution. */
26
27			/* Neither the name of the University nor the names of its contributors */
28			/* may be used to endorse or promote products derived from this software */
29			/* without specific prior written permission. */
30
31			/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
32			/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
33			/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
34			/* PURPOSE. */
35
36
37			#include "flexdef.h"
38
39			/* Take note: The buffer object is sometimes used as a String buffer (one
40			* continuous string), and sometimes used as a list of strings, usually line by
41			* line.
42			*
43			* The type is specified in buf_init by the elt_size. If the elt_size is
44			* sizeof(char), then the buffer should be treated as string buffer. If the
45			* elt_size is sizeof(char*), then the buffer should be treated as a list of
46			* strings.
47			*
48			* Certain functions are only appropriate for one type or the other.
49			*/
50
51			/* global buffers. */
52			struct Buf userdef_buf; /*< for user #definitions triggered by cmd-line. /
53			struct Buf defs_buf; /*< for #define's autogenerated. List of strings. /
54			struct Buf yydmap_buf; /*< string buffer to hold yydmap elements /
55			struct Buf m4defs_buf; /*< m4 definitions. List of strings. /
56			struct Buf top_buf; /*< contains %top code. String buffer. /
57
58			struct Buf *
59			buf_print_strings(struct Buf * buf, FILE * out)
60			{
61			int i;
62
63	✗✓	8	if (!buf \|\| !out)
64			return buf;
65
66	✓✓	60	for (i = 0; i < buf->nelts; i++) {
67		26	const char s = ((char *) buf->elts)[i];
68	✓✗	26	if (s)
69		26	fprintf(out, "%s", s);
70			}
71		4	return buf;
72		4	}
73
74			/* Append a "%s" formatted string to a string buffer */
75			struct Buf *
76			buf_prints(struct Buf * buf, const char fmt, const char s)
77			{
78			char *t;
79			size_t tsz;
80
81		52	tsz = strlen(fmt) + strlen(s) + 1;
82		26	t = malloc(tsz);
83	✗✓	26	if (!t)
84			flexfatal(_("Allocation of buffer to print string failed"));
85		26	snprintf(t, tsz, fmt, s);
86		26	buf = buf_strappend(buf, t);
87		26	free(t);
88		26	return buf;
89			}
90
91			/** Append a line directive to the string buffer.
92			* @param buf A string buffer.
93			* @param filename file name
94			* @param lineno line number
95			* @return buf
96			*/
97			struct Buf *
98			buf_linedir(struct Buf * buf, const char *filename, int lineno)
99			{
100			const char *src;
101			char dst, t;
102			size_t tsz;
103
104			tsz = strlen("#line \"\"\n") + /* constant parts */
105			2 * strlen(filename) + /* filename with possibly all backslashes escaped */
106			(int) (1 + log10(abs(lineno))) + /* line number */
107			1; /* NUL */
108			t = malloc(tsz);
109			if (!t)
110			flexfatal(_("Allocation of buffer for line directive failed"));
111			dst = t + snprintf(t, tsz, "#line %d \"", lineno);
112			for (src = filename; src; dst++ = *src++)
113			if (src == '\\') / escape backslashes */
114			*dst++ = '\\';
115			*dst++ = '"';
116			*dst++ = '\n';
117			*dst = '\0';
118			buf = buf_strappend(buf, t);
119			free(t);
120			return buf;
121			}
122
123
124			/** Append the contents of @a src to @a dest.
125			* @param @a dest the destination buffer
126			* @param @a dest the source buffer
127			* @return @a dest
128			*/
129			struct Buf *
130			buf_concat(struct Buf * dest, const struct Buf * src)
131			{
132			buf_append(dest, src->elts, src->nelts);
133			return dest;
134			}
135
136
137			/* Appends n characters in str to buf. */
138			struct Buf *
139			buf_strnappend(struct Buf buf, const char str, int n)
140			{
141		128	buf_append(buf, str, n + 1);
142
143			/* "undo" the '\0' character that buf_append() already copied. */
144		64	buf->nelts--;
145
146		64	return buf;
147			}
148
149			/* Appends characters in str to buf. */
150			struct Buf *
151			buf_strappend(struct Buf buf, const char str)
152			{
153		128	return buf_strnappend(buf, str, strlen(str));
154			}
155
156			/* appends "#define str def\n" */
157			struct Buf *
158			buf_strdefine(struct Buf buf, const char str, const char *def)
159			{
160		8	buf_strappend(buf, "#define ");
161		4	buf_strappend(buf, " ");
162		4	buf_strappend(buf, str);
163		4	buf_strappend(buf, " ");
164		4	buf_strappend(buf, def);
165		4	buf_strappend(buf, "\n");
166		4	return buf;
167			}
168
169			/** Pushes "m4_define( [[def]], [[val]])m4_dnl" to end of buffer.
170			* @param buf A buffer as a list of strings.
171			* @param def The m4 symbol to define.
172			* @param val The definition; may be NULL.
173			* @return buf
174			*/
175			struct Buf *
176			buf_m4_define(struct Buf * buf, const char def, const char val)
177			{
178			const char *fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
179		52	char *str;
180			size_t strsz;
181
182		26	val = val ? val : "";
183		26	strsz = strlen(fmt) + strlen(def) + strlen(val) + 2;
184		26	str = malloc(strsz);
185	✗✓	26	if (!str)
186			flexfatal(_("Allocation of buffer for m4 def failed"));
187
188		26	snprintf(str, strsz, fmt, def, val);
189		26	buf_append(buf, &str, 1);
190		26	return buf;
191		26	}
192
193			/** Pushes "m4_undefine([[def]])m4_dnl" to end of buffer.
194			* @param buf A buffer as a list of strings.
195			* @param def The m4 symbol to undefine.
196			* @return buf
197			*/
198			struct Buf *
199			buf_m4_undefine(struct Buf * buf, const char *def)
200			{
201			const char *fmt = "m4_undefine( [[%s]])m4_dnl\n";
202			char *str;
203			size_t strsz;
204
205			strsz = strlen(fmt) + strlen(def) + 2;
206			str = malloc(strsz);
207			if (!str)
208			flexfatal(_("Allocation of buffer for m4 undef failed"));
209
210			snprintf(str, strsz, fmt, def);
211			buf_append(buf, &str, 1);
212			return buf;
213			}
214
215			/* create buf with 0 elements, each of size elem_size. */
216			void
217			buf_init(struct Buf *buf, size_t elem_size)
218			{
219		128	buf->elts = NULL;
220		64	buf->nelts = 0;
221		64	buf->elt_size = elem_size;
222		64	buf->nmax = 0;
223		64	}
224
225			/* frees memory */
226			void
227			buf_destroy(struct Buf *buf)
228			{
229		8	free(buf->elts);
230		4	buf->elts = NULL;
231		4	}
232
233
234			/* appends ptr[] to buf, grow if necessary.
235			* n_elem is number of elements in ptr[], NOT bytes.
236			* returns buf.
237			* We grow by mod(512) boundaries.
238			*/
239
240			struct Buf *
241			buf_append(struct Buf buf, const void ptr, int n_elem)
242			{
243			int n_alloc = 0;
244
245	✗✓	216	if (!ptr \|\| n_elem == 0)
246			return buf;
247
248			/* May need to alloc more. */
249	✓✓	108	if (n_elem + buf->nelts > buf->nmax) {
250
251			/* exact amount needed... */
252		30	n_alloc = (n_elem + buf->nelts) * buf->elt_size;
253
254			/* ...plus some extra */
255	✓✗	60	if (((n_alloc * buf->elt_size) % 512) != 0
256	✓✗	60	&& buf->elt_size < 512)
257		30	n_alloc +=
258		30	(512 -
259		30	((n_alloc * buf->elt_size) % 512)) /
260			buf->elt_size;
261
262	✓✗	30	if (!buf->elts)
263		30	buf->elts =
264		30	allocate_array(n_alloc, buf->elt_size);
265			else
266			buf->elts =
267			reallocate_array(buf->elts, n_alloc,
268			buf->elt_size);
269
270		30	buf->nmax = n_alloc;
271		30	}
272		216	memcpy((char ) buf->elts + buf->nelts buf->elt_size, ptr,
273		108	n_elem * buf->elt_size);
274		108	buf->nelts += n_elem;
275
276		108	return buf;
277		108	}