Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/dc/inout.c	Lines:	200	207	96.6 %
Date:	2016-12-06	Branches:	86	104	82.7 %


/*	$OpenBSD: inout.c,v 1.19 2015/02/16 20:53:34 jca Exp $	*/

/*
 * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <ctype.h>
#include <err.h>
#include <string.h>

#include "extern.h"

#define MAX_CHARS_PER_LINE 68

static int	lastchar;
static int	charcount;

static int	src_getcharstream(struct source *);
static void	src_ungetcharstream(struct source *);
static char	*src_getlinestream(struct source *);
static void	src_freestream(struct source *);
static int	src_getcharstring(struct source *);
static void	src_ungetcharstring(struct source *);
static char	*src_getlinestring(struct source *);
static void	src_freestring(struct source *);
static void	flushwrap(FILE *);
static void	putcharwrap(FILE *, int);
static void	printwrap(FILE *, const char *);
static char	*get_digit(u_long, int, u_int);

static struct vtable stream_vtable = {
	src_getcharstream,
	src_ungetcharstream,
	src_getlinestream,
	src_freestream
};

static struct vtable string_vtable = {
	src_getcharstring,
	src_ungetcharstring,
	src_getlinestring,
	src_freestring
};

void
src_setstream(struct source *src, FILE *stream)
{
	src->u.stream = stream;
	src->vtable = &stream_vtable;
}

void
src_setstring(struct source *src, char *p)
{
	src->u.string.buf = (u_char *)p;
	src->u.string.pos = 0;
	src->vtable = &string_vtable;
}

static int
src_getcharstream(struct source *src)
{
	return src->lastchar = getc(src->u.stream);
}

static void
src_ungetcharstream(struct source *src)
{
	(void)ungetc(src->lastchar, src->u.stream);
}

/* ARGSUSED */
static void
src_freestream(struct source *src)
{
}

static char *
src_getlinestream(struct source *src)
{
	char buf[BUFSIZ];

	if (fgets(buf, BUFSIZ, src->u.stream) == NULL)
		return bstrdup("");
	return bstrdup(buf);
}

static int
src_getcharstring(struct source *src)
{
	src->lastchar = src->u.string.buf[src->u.string.pos];
	if (src->lastchar == '\0')
		return EOF;
	else {
		src->u.string.pos++;
		return src->lastchar;
	}
}

static void
src_ungetcharstring(struct source *src)
{
	if (src->u.string.pos > 0) {
		if (src->lastchar != '\0')
			--src->u.string.pos;
	}
}

static char *
src_getlinestring(struct source *src)
{
	char buf[BUFSIZ];
	int ch, i;

	i = 0;
	while (i < BUFSIZ-1) {
		ch = src_getcharstring(src);
		if (ch == EOF)
			break;
		buf[i++] = ch;
		if (ch == '\n')
			break;
	}
	buf[i] = '\0';
	return bstrdup(buf);
}

static void
src_freestring(struct source *src)
{
	free(src->u.string.buf);
}

static void
flushwrap(FILE *f)
{
	if (lastchar != -1)
		(void)putc(lastchar, f);
}

static void
putcharwrap(FILE *f, int ch)
{
	if (charcount >= MAX_CHARS_PER_LINE) {
		charcount = 0;
		(void)fputs("\\\n", f);
	}
	if (lastchar != -1) {
		charcount++;
		(void)putc(lastchar, f);
	}
	lastchar = ch;
}

static void
printwrap(FILE *f, const char *p)
{
	char	buf[12];
	char	*q = buf;

	(void)strlcpy(buf, p, sizeof(buf));
	while (*q)
		putcharwrap(f, *q++);
}

struct number *
readnumber(struct source *src, u_int base)
{
	struct number	*n;
	int		ch;
	bool		sign = false;
	bool		dot = false;
	BN_ULONG	v;
	u_int		i;

	n = new_number();
	bn_check(BN_zero(n->number));

	while ((ch = (*src->vtable->readchar)(src)) != EOF) {

		if ('0' <= ch && ch <= '9')
			v = ch - '0';
		else if ('A' <= ch && ch <= 'F')
			v = ch - 'A' + 10;
		else if (ch == '_') {
			sign = true;
			continue;
		} else if (ch == '.') {
			if (dot)
				break;
			dot = true;
			continue;
		} else {
			(*src->vtable->unreadchar)(src);
			break;
		}
		if (dot)
			n->scale++;

		bn_check(BN_mul_word(n->number, base));

#if 0
		/* work around a bug in BN_add_word: 0 += 0 is buggy.... */
		if (v > 0)
#endif
			bn_check(BN_add_word(n->number, v));
	}
	if (base != 10) {
		scale_number(n->number, n->scale);
		for (i = 0; i < n->scale; i++)
			(void)BN_div_word(n->number, base);
	}
	if (sign)
		negate(n);
	return n;
}

char *
read_string(struct source *src)
{
	int count, i, sz, new_sz, ch;
	char *p;
	bool escape;

	escape = false;
	count = 1;
	i = 0;
	sz = 15;
	p = bmalloc(sz + 1);

	while ((ch = (*src->vtable->readchar)(src)) != EOF) {
		if (!escape) {
			if (ch == '[')
				count++;
			else if (ch == ']')
				count--;
			if (count == 0)
				break;
		}
		if (ch == '\\' && !escape)
			escape = true;
		else {
			escape = false;
			if (i == sz) {
				new_sz = sz * 2;
				p = breallocarray(p, 1, new_sz + 1);
				sz = new_sz;
			}
			p[i++] = ch;
		}
	}
	p[i] = '\0';
	return p;
}

static char *
get_digit(u_long num, int digits, u_int base)
{
	char *p;

	if (base <= 16) {
		p = bmalloc(2);
		p[0] = num >= 10 ? num + 'A' - 10 : num + '0';
		p[1] = '\0';
	} else {
		if (asprintf(&p, "%0*lu", digits, num) == -1)
			err(1, NULL);
	}
	return p;
}

void
printnumber(FILE *f, const struct number *b, u_int base)
{
	struct number	*int_part, *fract_part;
	int		digits;
	char		buf[11];
	size_t		sz;
	int		i;
	struct stack	stack;
	char		*p;

	charcount = 0;
	lastchar = -1;
	if (BN_is_zero(b->number))
		putcharwrap(f, '0');

	int_part = new_number();
	fract_part = new_number();
	fract_part->scale = b->scale;

	if (base <= 16)
		digits = 1;
	else {
		digits = snprintf(buf, sizeof(buf), "%u", base-1);
	}
	split_number(b, int_part->number, fract_part->number);

	i = 0;
	stack_init(&stack);
	while (!BN_is_zero(int_part->number)) {
		BN_ULONG rem = BN_div_word(int_part->number, base);
		stack_pushstring(&stack, get_digit(rem, digits, base));
		i++;
	}
	sz = i;
	if (BN_is_negative(b->number))
		putcharwrap(f, '-');
	for (i = 0; i < sz; i++) {
		p = stack_popstring(&stack);
		if (base > 16)
			putcharwrap(f, ' ');
		printwrap(f, p);
		free(p);
	}
	stack_clear(&stack);
	if (b->scale > 0) {
		struct number	*num_base;
		BIGNUM		mult, stop;

		putcharwrap(f, '.');
		num_base = new_number();
		bn_check(BN_set_word(num_base->number, base));
		BN_init(&mult);
		bn_check(BN_one(&mult));
		BN_init(&stop);
		bn_check(BN_one(&stop));
		scale_number(&stop, b->scale);

		i = 0;
		while (BN_cmp(&mult, &stop) < 0) {
			u_long	rem;

			if (i && base > 16)
				putcharwrap(f, ' ');
			i = 1;

			bmul_number(fract_part, fract_part, num_base,
			    bmachine_scale());
			split_number(fract_part, int_part->number, NULL);
			rem = BN_get_word(int_part->number);
			p = get_digit(rem, digits, base);
			int_part->scale = 0;
			normalize(int_part, fract_part->scale);
			bn_check(BN_sub(fract_part->number, fract_part->number,
			    int_part->number));
			printwrap(f, p);
			free(p);
			bn_check(BN_mul_word(&mult, base));
		}
		free_number(num_base);
		BN_free(&mult);
		BN_free(&stop);
	}
	flushwrap(f);
	free_number(int_part);
	free_number(fract_part);
}

void
print_value(FILE *f, const struct value *value, const char *prefix, u_int base)
{
	(void)fputs(prefix, f);
	switch (value->type) {
	case BCODE_NONE:
		if (value->array != NULL)
			(void)fputs("<array>", f);
		break;
	case BCODE_NUMBER:
		printnumber(f, value->u.num, base);
		break;
	case BCODE_STRING:
		(void)fputs(value->u.string, f);
		break;
	}
}

void
print_ascii(FILE *f, const struct number *n)
{
	BIGNUM *v;
	int numbits, i, ch;

	v = BN_dup(n->number);
	bn_checkp(v);

	if (BN_is_negative(v))
		BN_set_negative(v, 0);

	numbits = BN_num_bytes(v) * 8;
	while (numbits > 0) {
		ch = 0;
		for (i = 0; i < 8; i++)
			ch |= BN_is_bit_set(v, numbits-i-1) << (7 - i);
		(void)putc(ch, f);
		numbits -= 8;
	}
	BN_free(v);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: inout.c,v 1.19 2015/02/16 20:53:34 jca Exp $ */
2
3			/*
4			* Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <ctype.h>
20			#include <err.h>
21			#include <string.h>
22
23			#include "extern.h"
24
25			#define MAX_CHARS_PER_LINE 68
26
27			static int lastchar;
28			static int charcount;
29
30			static int src_getcharstream(struct source *);
31			static void src_ungetcharstream(struct source *);
32			static char src_getlinestream(struct source );
33			static void src_freestream(struct source *);
34			static int src_getcharstring(struct source *);
35			static void src_ungetcharstring(struct source *);
36			static char src_getlinestring(struct source );
37			static void src_freestring(struct source *);
38			static void flushwrap(FILE *);
39			static void putcharwrap(FILE *, int);
40			static void printwrap(FILE , const char );
41			static char *get_digit(u_long, int, u_int);
42
43			static struct vtable stream_vtable = {
44			src_getcharstream,
45			src_ungetcharstream,
46			src_getlinestream,
47			src_freestream
48			};
49
50			static struct vtable string_vtable = {
51			src_getcharstring,
52			src_ungetcharstring,
53			src_getlinestring,
54			src_freestring
55			};
56
57			void
58			src_setstream(struct source src, FILE stream)
59		27	{
60		27	src->u.stream = stream;
61		27	src->vtable = &stream_vtable;
62		27	}
63
64			void
65			src_setstring(struct source src, char p)
66		5223	{
67		5223	src->u.string.buf = (u_char *)p;
68		5223	src->u.string.pos = 0;
69		5223	src->vtable = &string_vtable;
70		5223	}
71
72			static int
73			src_getcharstream(struct source *src)
74		65561	{
75	✓✗✓✓	65561	return src->lastchar = getc(src->u.stream);
76			}
77
78			static void
79			src_ungetcharstream(struct source *src)
80		9304	{
81		9304	(void)ungetc(src->lastchar, src->u.stream);
82		9304	}
83
84			/* ARGSUSED */
85			static void
86			src_freestream(struct source *src)
87			{
88			}
89
90			static char *
91			src_getlinestream(struct source *src)
92		41	{
93			char buf[BUFSIZ];
94
95	✗✓	41	if (fgets(buf, BUFSIZ, src->u.stream) == NULL)
96			return bstrdup("");
97		41	return bstrdup(buf);
98			}
99
100			static int
101			src_getcharstring(struct source *src)
102		204220	{
103		204220	src->lastchar = src->u.string.buf[src->u.string.pos];
104	✓✓	204220	if (src->lastchar == '\0')
105		7302	return EOF;
106			else {
107		196918	src->u.string.pos++;
108		196918	return src->lastchar;
109			}
110			}
111
112			static void
113			src_ungetcharstring(struct source *src)
114		37447	{
115	✓✗	37447	if (src->u.string.pos > 0) {
116	✓✓	37447	if (src->lastchar != '\0')
117		34346	--src->u.string.pos;
118			}
119		37447	}
120
121			static char *
122			src_getlinestring(struct source *src)
123		1294	{
124			char buf[BUFSIZ];
125			int ch, i;
126
127		1294	i = 0;
128	✓✗	13778	while (i < BUFSIZ-1) {
129		12484	ch = src_getcharstring(src);
130	✗✓	12484	if (ch == EOF)
131			break;
132		12484	buf[i++] = ch;
133	✓✓	12484	if (ch == '\n')
134		1294	break;
135			}
136		1294	buf[i] = '\0';
137		1294	return bstrdup(buf);
138			}
139
140			static void
141			src_freestring(struct source *src)
142		5223	{
143		5223	free(src->u.string.buf);
144		5223	}
145
146			static void
147			flushwrap(FILE *f)
148		5102	{
149	✓✗	5102	if (lastchar != -1)
150	✓✗	5102	(void)putc(lastchar, f);
151		5102	}
152
153			static void
154			putcharwrap(FILE *f, int ch)
155		32995	{
156	✓✓	32995	if (charcount >= MAX_CHARS_PER_LINE) {
157		211	charcount = 0;
158		211	(void)fputs("\\\n", f);
159			}
160	✓✓	32995	if (lastchar != -1) {
161		27893	charcount++;
162	✓✗	27893	(void)putc(lastchar, f);
163			}
164		32995	lastchar = ch;
165		32995	}
166
167			static void
168			printwrap(FILE f, const char p)
169		28518	{
170			char buf[12];
171		28518	char *q = buf;
172
173		28518	(void)strlcpy(buf, p, sizeof(buf));
174	✓✓	86982	while (*q)
175		29946	putcharwrap(f, *q++);
176		28518	}
177
178			struct number *
179			readnumber(struct source *src, u_int base)
180		19398	{
181			struct number *n;
182			int ch;
183		19398	bool sign = false;
184		19398	bool dot = false;
185			BN_ULONG v;
186			u_int i;
187
188		19398	n = new_number();
189		19398	bn_check(BN_zero(n->number));
190
191	✓✓	85058	while ((ch = (*src->vtable->readchar)(src)) != EOF) {
192
193	✓✓	65654	if ('0' <= ch && ch <= '9')
194		44148	v = ch - '0';
195	✓✓	21506	else if ('A' <= ch && ch <= 'F')
196		22	v = ch - 'A' + 10;
197	✓✓	21484	else if (ch == '_') {
198		35	sign = true;
199		35	continue;
200	✓✓	21449	} else if (ch == '.') {
201	✗✓	2057	if (dot)
202			break;
203		2057	dot = true;
204		2057	continue;
205			} else {
206		19392	(*src->vtable->unreadchar)(src);
207		19392	break;
208			}
209	✓✓	44170	if (dot)
210		4216	n->scale++;
211
212		44170	bn_check(BN_mul_word(n->number, base));
213
214			#if 0
215			/* work around a bug in BN_add_word: 0 += 0 is buggy.... */
216			if (v > 0)
217			#endif
218		44170	bn_check(BN_add_word(n->number, v));
219			}
220	✓✓	19398	if (base != 10) {
221		74	scale_number(n->number, n->scale);
222	✓✓	127	for (i = 0; i < n->scale; i++)
223		53	(void)BN_div_word(n->number, base);
224			}
225	✓✓	19398	if (sign)
226		35	negate(n);
227		19398	return n;
228			}
229
230			char *
231			read_string(struct source *src)
232		654	{
233			int count, i, sz, new_sz, ch;
234			char *p;
235			bool escape;
236
237		654	escape = false;
238		654	count = 1;
239		654	i = 0;
240		654	sz = 15;
241		654	p = bmalloc(sz + 1);
242
243	✓✗	8272	while ((ch = (*src->vtable->readchar)(src)) != EOF) {
244	✓✓	7618	if (!escape) {
245	✓✓	7617	if (ch == '[')
246		86	count++;
247	✓✓	7531	else if (ch == ']')
248		740	count--;
249	✓✓	7617	if (count == 0)
250		654	break;
251			}
252	✓✓✓✗	6965	if (ch == '\\' && !escape)
253		1	escape = true;
254			else {
255		6963	escape = false;
256	✓✓	6963	if (i == sz) {
257		157	new_sz = sz * 2;
258		157	p = breallocarray(p, 1, new_sz + 1);
259		157	sz = new_sz;
260			}
261		6963	p[i++] = ch;
262			}
263			}
264		654	p[i] = '\0';
265		654	return p;
266			}
267
268			static char *
269			get_digit(u_long num, int digits, u_int base)
270		28518	{
271			char *p;
272
273	✓✓	28518	if (base <= 16) {
274		27692	p = bmalloc(2);
275	✓✓	27692	p[0] = num >= 10 ? num + 'A' - 10 : num + '0';
276		27692	p[1] = '\0';
277			} else {
278	✗✓	826	if (asprintf(&p, "%0*lu", digits, num) == -1)
279			err(1, NULL);
280			}
281		28518	return p;
282			}
283
284			void
285			printnumber(FILE f, const struct number b, u_int base)
286		5102	{
287			struct number int_part, fract_part;
288			int digits;
289			char buf[11];
290			size_t sz;
291			int i;
292			struct stack stack;
293			char *p;
294
295		5102	charcount = 0;
296		5102	lastchar = -1;
297	✓✓	5102	if (BN_is_zero(b->number))
298		32	putcharwrap(f, '0');
299
300		5102	int_part = new_number();
301		5102	fract_part = new_number();
302		5102	fract_part->scale = b->scale;
303
304	✓✓	5102	if (base <= 16)
305		4966	digits = 1;
306			else {
307		136	digits = snprintf(buf, sizeof(buf), "%u", base-1);
308			}
309		5102	split_number(b, int_part->number, fract_part->number);
310
311		5102	i = 0;
312		5102	stack_init(&stack);
313	✓✓	33820	while (!BN_is_zero(int_part->number)) {
314		23616	BN_ULONG rem = BN_div_word(int_part->number, base);
315		23616	stack_pushstring(&stack, get_digit(rem, digits, base));
316		23616	i++;
317			}
318		5102	sz = i;
319	✓✓	5102	if (BN_is_negative(b->number))
320		105	putcharwrap(f, '-');
321	✓✓	28718	for (i = 0; i < sz; i++) {
322		23616	p = stack_popstring(&stack);
323	✓✓	23616	if (base > 16)
324		788	putcharwrap(f, ' ');
325		23616	printwrap(f, p);
326		23616	free(p);
327			}
328		5102	stack_clear(&stack);
329	✓✓	5102	if (b->scale > 0) {
330			struct number *num_base;
331			BIGNUM mult, stop;
332
333		2118	putcharwrap(f, '.');
334		2118	num_base = new_number();
335		2118	bn_check(BN_set_word(num_base->number, base));
336		2118	BN_init(&mult);
337		2118	bn_check(BN_one(&mult));
338		2118	BN_init(&stop);
339		2118	bn_check(BN_one(&stop));
340		2118	scale_number(&stop, b->scale);
341
342		2118	i = 0;
343	✓✓	9138	while (BN_cmp(&mult, &stop) < 0) {
344			u_long rem;
345
346	✓✓	4902	if (i && base > 16)
347		6	putcharwrap(f, ' ');
348		4902	i = 1;
349
350		4902	bmul_number(fract_part, fract_part, num_base,
351			bmachine_scale());
352		4902	split_number(fract_part, int_part->number, NULL);
353		4902	rem = BN_get_word(int_part->number);
354		4902	p = get_digit(rem, digits, base);
355		4902	int_part->scale = 0;
356		4902	normalize(int_part, fract_part->scale);
357		4902	bn_check(BN_sub(fract_part->number, fract_part->number,
358			int_part->number));
359		4902	printwrap(f, p);
360		4902	free(p);
361		4902	bn_check(BN_mul_word(&mult, base));
362			}
363		2118	free_number(num_base);
364		2118	BN_free(&mult);
365		2118	BN_free(&stop);
366			}
367		5102	flushwrap(f);
368		5102	free_number(int_part);
369		5102	free_number(fract_part);
370		5102	}
371
372			void
373			print_value(FILE f, const struct value value, const char *prefix, u_int base)
374		5262	{
375		5262	(void)fputs(prefix, f);
376	✗✓✓✗	5262	switch (value->type) {
377			case BCODE_NONE:
378			if (value->array != NULL)
379			(void)fputs("<array>", f);
380			break;
381			case BCODE_NUMBER:
382		5102	printnumber(f, value->u.num, base);
383		5102	break;
384			case BCODE_STRING:
385		160	(void)fputs(value->u.string, f);
386			break;
387			}
388		5262	}
389
390			void
391			print_ascii(FILE f, const struct number n)
392		1975	{
393			BIGNUM *v;
394			int numbits, i, ch;
395
396		1975	v = BN_dup(n->number);
397		1975	bn_checkp(v);
398
399	✗✓	1975	if (BN_is_negative(v))
400			BN_set_negative(v, 0);
401
402		1975	numbits = BN_num_bytes(v) * 8;
403	✓✓	5924	while (numbits > 0) {
404		1974	ch = 0;
405	✓✓	17766	for (i = 0; i < 8; i++)
406		15792	ch \|= BN_is_bit_set(v, numbits-i-1) << (7 - i);
407	✓✗	1974	(void)putc(ch, f);
408		1974	numbits -= 8;
409			}
410		1975	BN_free(v);
411		1975	}