parse.c revision 97329 
1/*
2 * Copyright (c) 1989, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 *    must display the following acknowledgement:
15 *	This product includes software developed by the University of
16 *	California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35#if 0
36static char sccsid[] = "@(#)parse.c	8.1 (Berkeley) 6/6/93";
37#endif
38static const char rcsid[] =
39  "$FreeBSD: head/usr.bin/hexdump/parse.c 97329 2002-05-27 03:17:28Z tjr $";
40#endif /* not lint */
41
42#include <sys/types.h>
43
44#include <err.h>
45#include <fcntl.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <ctype.h>
49#include <string.h>
50#include "hexdump.h"
51
52FU *endfu;					/* format at end-of-data */
53
54void
55addfile(name)
56	char *name;
57{
58	register unsigned char *p;
59	FILE *fp;
60	int ch;
61	char buf[2048 + 1];
62
63	if ((fp = fopen(name, "r")) == NULL)
64		err(1, "%s", name);
65	while (fgets(buf, sizeof(buf), fp)) {
66		if (!(p = index(buf, '\n'))) {
67			warnx("line too long");
68			while ((ch = getchar()) != '\n' && ch != EOF);
69			continue;
70		}
71		*p = '\0';
72		for (p = buf; *p && isspace(*p); ++p);
73		if (!*p || *p == '#')
74			continue;
75		add(p);
76	}
77	(void)fclose(fp);
78}
79
80void
81add(fmt)
82	const char *fmt;
83{
84	unsigned const char *p, *savep;
85	static FS **nextfs;
86	FS *tfs;
87	FU *tfu, **nextfu;
88
89	/* start new linked list of format units */
90	if ((tfs = calloc(1, sizeof(FS))) == NULL)
91		err(1, NULL);
92	if (!fshead)
93		fshead = tfs;
94	else
95		*nextfs = tfs;
96	nextfs = &tfs->nextfs;
97	nextfu = &tfs->nextfu;
98
99	/* take the format string and break it up into format units */
100	for (p = fmt;;) {
101		/* skip leading white space */
102		for (; isspace(*p); ++p);
103		if (!*p)
104			break;
105
106		/* allocate a new format unit and link it in */
107		if ((tfu = calloc(1, sizeof(FU))) == NULL)
108			err(1, NULL);
109		*nextfu = tfu;
110		nextfu = &tfu->nextfu;
111		tfu->reps = 1;
112
113		/* if leading digit, repetition count */
114		if (isdigit(*p)) {
115			for (savep = p; isdigit(*p); ++p);
116			if (!isspace(*p) && *p != '/')
117				badfmt(fmt);
118			/* may overwrite either white space or slash */
119			tfu->reps = atoi(savep);
120			tfu->flags = F_SETREP;
121			/* skip trailing white space */
122			for (++p; isspace(*p); ++p);
123		}
124
125		/* skip slash and trailing white space */
126		if (*p == '/')
127			while (isspace(*++p));
128
129		/* byte count */
130		if (isdigit(*p)) {
131			for (savep = p; isdigit(*p); ++p);
132			if (!isspace(*p))
133				badfmt(fmt);
134			tfu->bcnt = atoi(savep);
135			/* skip trailing white space */
136			for (++p; isspace(*p); ++p);
137		}
138
139		/* format */
140		if (*p != '"')
141			badfmt(fmt);
142		for (savep = ++p; *p != '"';)
143			if (*p++ == 0)
144				badfmt(fmt);
145		if (!(tfu->fmt = malloc(p - savep + 1)))
146			err(1, NULL);
147		(void) strncpy(tfu->fmt, savep, p - savep);
148		tfu->fmt[p - savep] = '\0';
149		escape(tfu->fmt);
150		p++;
151	}
152}
153
154static const char *spec = ".#-+ 0123456789";
155
156int
157size(fs)
158	FS *fs;
159{
160	register FU *fu;
161	register int bcnt, cursize;
162	register unsigned char *fmt;
163	int prec;
164
165	/* figure out the data block size needed for each format unit */
166	for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
167		if (fu->bcnt) {
168			cursize += fu->bcnt * fu->reps;
169			continue;
170		}
171		for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
172			if (*fmt != '%')
173				continue;
174			/*
175			 * skip any special chars -- save precision in
176			 * case it's a %s format.
177			 */
178			while (index(spec + 1, *++fmt));
179			if (*fmt == '.' && isdigit(*++fmt)) {
180				prec = atoi(fmt);
181				while (isdigit(*++fmt));
182			}
183			switch(*fmt) {
184			case 'c':
185				bcnt += 1;
186				break;
187			case 'd': case 'i': case 'o': case 'u':
188			case 'x': case 'X':
189				bcnt += 4;
190				break;
191			case 'e': case 'E': case 'f': case 'g': case 'G':
192				bcnt += 8;
193				break;
194			case 's':
195				bcnt += prec;
196				break;
197			case '_':
198				switch(*++fmt) {
199				case 'c': case 'p': case 'u':
200					bcnt += 1;
201					break;
202				}
203			}
204		}
205		cursize += bcnt * fu->reps;
206	}
207	return (cursize);
208}
209
210void
211rewrite(fs)
212	FS *fs;
213{
214	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
215	register PR *pr, **nextpr;
216	register FU *fu;
217	unsigned char *p1, *p2, *fmtp;
218	char savech, cs[3];
219	int nconv, prec;
220
221	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
222		/*
223		 * Break each format unit into print units; each conversion
224		 * character gets its own.
225		 */
226		for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
227			if ((pr = calloc(1, sizeof(PR))) == NULL)
228				err(1, NULL);
229			if (!fu->nextpr)
230				fu->nextpr = pr;
231			else
232				*nextpr = pr;
233
234			/* Skip preceding text and up to the next % sign. */
235			for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
236
237			/* Only text in the string. */
238			if (!*p1) {
239				pr->fmt = fmtp;
240				pr->flags = F_TEXT;
241				break;
242			}
243
244			/*
245			 * Get precision for %s -- if have a byte count, don't
246			 * need it.
247			 */
248			if (fu->bcnt) {
249				sokay = USEBCNT;
250				/* Skip to conversion character. */
251				for (++p1; index(spec, *p1); ++p1);
252			} else {
253				/* Skip any special chars, field width. */
254				while (index(spec + 1, *++p1));
255				if (*p1 == '.' && isdigit(*++p1)) {
256					sokay = USEPREC;
257					prec = atoi(p1);
258					while (isdigit(*++p1));
259				} else
260					sokay = NOTOKAY;
261			}
262
263			p2 = p1 + 1;		/* Set end pointer. */
264			cs[0] = *p1;		/* Set conversion string. */
265			cs[1] = '\0';
266
267			/*
268			 * Figure out the byte count for each conversion;
269			 * rewrite the format as necessary, set up blank-
270			 * padding for end of data.
271			 */
272			switch(cs[0]) {
273			case 'c':
274				pr->flags = F_CHAR;
275				switch(fu->bcnt) {
276				case 0: case 1:
277					pr->bcnt = 1;
278					break;
279				default:
280					p1[1] = '\0';
281					badcnt(p1);
282				}
283				break;
284			case 'd': case 'i':
285				pr->flags = F_INT;
286				goto isint;
287			case 'o': case 'u': case 'x': case 'X':
288				pr->flags = F_UINT;
289isint:				cs[2] = '\0';
290				cs[1] = cs[0];
291				cs[0] = 'q';
292				switch(fu->bcnt) {
293				case 0: case 4:
294					pr->bcnt = 4;
295					break;
296				case 1:
297					pr->bcnt = 1;
298					break;
299				case 2:
300					pr->bcnt = 2;
301					break;
302				default:
303					p1[1] = '\0';
304					badcnt(p1);
305				}
306				break;
307			case 'e': case 'E': case 'f': case 'g': case 'G':
308				pr->flags = F_DBL;
309				switch(fu->bcnt) {
310				case 0: case 8:
311					pr->bcnt = 8;
312					break;
313				case 4:
314					pr->bcnt = 4;
315					break;
316				default:
317					if (fu->bcnt == sizeof(long double)) {
318						cs[2] = '\0';
319						cs[1] = cs[0];
320						cs[0] = 'L';
321						pr->bcnt = sizeof(long double);
322					} else {
323						p1[1] = '\0';
324						badcnt(p1);
325					}
326				}
327				break;
328			case 's':
329				pr->flags = F_STR;
330				switch(sokay) {
331				case NOTOKAY:
332					badsfmt();
333				case USEBCNT:
334					pr->bcnt = fu->bcnt;
335					break;
336				case USEPREC:
337					pr->bcnt = prec;
338					break;
339				}
340				break;
341			case '_':
342				++p2;
343				switch(p1[1]) {
344				case 'A':
345					endfu = fu;
346					fu->flags |= F_IGNORE;
347					/* FALLTHROUGH */
348				case 'a':
349					pr->flags = F_ADDRESS;
350					++p2;
351					switch(p1[2]) {
352					case 'd': case 'o': case'x':
353						cs[0] = 'q';
354						cs[1] = p1[2];
355						cs[2] = '\0';
356						break;
357					default:
358						p1[3] = '\0';
359						badconv(p1);
360					}
361					break;
362				case 'c':
363					pr->flags = F_C;
364					/* cs[0] = 'c';	set in conv_c */
365					goto isint2;
366				case 'p':
367					pr->flags = F_P;
368					cs[0] = 'c';
369					goto isint2;
370				case 'u':
371					pr->flags = F_U;
372					/* cs[0] = 'c';	set in conv_u */
373isint2:					switch(fu->bcnt) {
374					case 0: case 1:
375						pr->bcnt = 1;
376						break;
377					default:
378						p1[2] = '\0';
379						badcnt(p1);
380					}
381					break;
382				default:
383					p1[2] = '\0';
384					badconv(p1);
385				}
386				break;
387			default:
388				p1[1] = '\0';
389				badconv(p1);
390			}
391
392			/*
393			 * Copy to PR format string, set conversion character
394			 * pointer, update original.
395			 */
396			savech = *p2;
397			p1[0] = '\0';
398			if ((pr->fmt = calloc(1, strlen(fmtp) + 2)) == NULL)
399				err(1, NULL);
400			(void)strcpy(pr->fmt, fmtp);
401			(void)strcat(pr->fmt, cs);
402			*p2 = savech;
403			pr->cchar = pr->fmt + (p1 - fmtp);
404			fmtp = p2;
405
406			/* Only one conversion character if byte count. */
407			if (!(pr->flags&F_ADDRESS) && fu->bcnt && nconv++)
408	    errx(1, "byte count with multiple conversion characters");
409		}
410		/*
411		 * If format unit byte count not specified, figure it out
412		 * so can adjust rep count later.
413		 */
414		if (!fu->bcnt)
415			for (pr = fu->nextpr; pr; pr = pr->nextpr)
416				fu->bcnt += pr->bcnt;
417	}
418	/*
419	 * If the format string interprets any data at all, and it's
420	 * not the same as the blocksize, and its last format unit
421	 * interprets any data at all, and has no iteration count,
422	 * repeat it as necessary.
423	 *
424	 * If, rep count is greater than 1, no trailing whitespace
425	 * gets output from the last iteration of the format unit.
426	 */
427	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
428		if (!fu->nextfu && fs->bcnt < blocksize &&
429		    !(fu->flags&F_SETREP) && fu->bcnt)
430			fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
431		if (fu->reps > 1) {
432			for (pr = fu->nextpr;; pr = pr->nextpr)
433				if (!pr->nextpr)
434					break;
435			for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
436				p2 = isspace(*p1) ? p1 : NULL;
437			if (p2)
438				pr->nospace = p2;
439		}
440	}
441#ifdef DEBUG
442	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
443		(void)printf("fmt:");
444		for (pr = fu->nextpr; pr; pr = pr->nextpr)
445			(void)printf(" {%s}", pr->fmt);
446		(void)printf("\n");
447	}
448#endif
449}
450
451void
452escape(p1)
453	register char *p1;
454{
455	register char *p2;
456
457	/* alphabetic escape sequences have to be done in place */
458	for (p2 = p1;; ++p1, ++p2) {
459		if (!*p1) {
460			*p2 = *p1;
461			break;
462		}
463		if (*p1 == '\\')
464			switch(*++p1) {
465			case 'a':
466			     /* *p2 = '\a'; */
467				*p2 = '\007';
468				break;
469			case 'b':
470				*p2 = '\b';
471				break;
472			case 'f':
473				*p2 = '\f';
474				break;
475			case 'n':
476				*p2 = '\n';
477				break;
478			case 'r':
479				*p2 = '\r';
480				break;
481			case 't':
482				*p2 = '\t';
483				break;
484			case 'v':
485				*p2 = '\v';
486				break;
487			default:
488				*p2 = *p1;
489				break;
490			}
491	}
492}
493
494void
495badcnt(s)
496	char *s;
497{
498	errx(1, "%s: bad byte count", s);
499}
500
501void
502badsfmt()
503{
504	errx(1, "%%s: requires a precision or a byte count");
505}
506
507void
508badfmt(fmt)
509	const char *fmt;
510{
511	errx(1, "\"%s\": bad format", fmt);
512}
513
514void
515badconv(ch)
516	char *ch;
517{
518	errx(1, "%%%s: bad conversion character", ch);
519}
520