parse.c revision 132541 
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
38#endif /* not lint */
39#include <sys/cdefs.h>
40__FBSDID("$FreeBSD: head/usr.bin/hexdump/parse.c 132541 2004-07-22 13:14:42Z johan $");
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(char *name)
56{
57	unsigned char *p;
58	FILE *fp;
59	int ch;
60	char buf[2048 + 1];
61
62	if ((fp = fopen(name, "r")) == NULL)
63		err(1, "%s", name);
64	while (fgets(buf, sizeof(buf), fp)) {
65		if (!(p = index(buf, '\n'))) {
66			warnx("line too long");
67			while ((ch = getchar()) != '\n' && ch != EOF);
68			continue;
69		}
70		*p = '\0';
71		for (p = buf; *p && isspace(*p); ++p);
72		if (!*p || *p == '#')
73			continue;
74		add(p);
75	}
76	(void)fclose(fp);
77}
78
79void
80add(const char *fmt)
81{
82	unsigned const char *p, *savep;
83	static FS **nextfs;
84	FS *tfs;
85	FU *tfu, **nextfu;
86
87	/* start new linked list of format units */
88	if ((tfs = calloc(1, sizeof(FS))) == NULL)
89		err(1, NULL);
90	if (!fshead)
91		fshead = tfs;
92	else
93		*nextfs = tfs;
94	nextfs = &tfs->nextfs;
95	nextfu = &tfs->nextfu;
96
97	/* take the format string and break it up into format units */
98	for (p = fmt;;) {
99		/* skip leading white space */
100		for (; isspace(*p); ++p);
101		if (!*p)
102			break;
103
104		/* allocate a new format unit and link it in */
105		if ((tfu = calloc(1, sizeof(FU))) == NULL)
106			err(1, NULL);
107		*nextfu = tfu;
108		nextfu = &tfu->nextfu;
109		tfu->reps = 1;
110
111		/* if leading digit, repetition count */
112		if (isdigit(*p)) {
113			for (savep = p; isdigit(*p); ++p);
114			if (!isspace(*p) && *p != '/')
115				badfmt(fmt);
116			/* may overwrite either white space or slash */
117			tfu->reps = atoi(savep);
118			tfu->flags = F_SETREP;
119			/* skip trailing white space */
120			for (++p; isspace(*p); ++p);
121		}
122
123		/* skip slash and trailing white space */
124		if (*p == '/')
125			while (isspace(*++p));
126
127		/* byte count */
128		if (isdigit(*p)) {
129			for (savep = p; isdigit(*p); ++p);
130			if (!isspace(*p))
131				badfmt(fmt);
132			tfu->bcnt = atoi(savep);
133			/* skip trailing white space */
134			for (++p; isspace(*p); ++p);
135		}
136
137		/* format */
138		if (*p != '"')
139			badfmt(fmt);
140		for (savep = ++p; *p != '"';)
141			if (*p++ == 0)
142				badfmt(fmt);
143		if (!(tfu->fmt = malloc(p - savep + 1)))
144			err(1, NULL);
145		(void) strncpy(tfu->fmt, savep, p - savep);
146		tfu->fmt[p - savep] = '\0';
147		escape(tfu->fmt);
148		p++;
149	}
150}
151
152static const char *spec = ".#-+ 0123456789";
153
154int
155size(FS *fs)
156{
157	FU *fu;
158	int bcnt, cursize;
159	unsigned char *fmt;
160	int prec;
161
162	/* figure out the data block size needed for each format unit */
163	for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
164		if (fu->bcnt) {
165			cursize += fu->bcnt * fu->reps;
166			continue;
167		}
168		for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
169			if (*fmt != '%')
170				continue;
171			/*
172			 * skip any special chars -- save precision in
173			 * case it's a %s format.
174			 */
175			while (index(spec + 1, *++fmt));
176			if (*fmt == '.' && isdigit(*++fmt)) {
177				prec = atoi(fmt);
178				while (isdigit(*++fmt));
179			}
180			switch(*fmt) {
181			case 'c':
182				bcnt += 1;
183				break;
184			case 'd': case 'i': case 'o': case 'u':
185			case 'x': case 'X':
186				bcnt += 4;
187				break;
188			case 'e': case 'E': case 'f': case 'g': case 'G':
189				bcnt += 8;
190				break;
191			case 's':
192				bcnt += prec;
193				break;
194			case '_':
195				switch(*++fmt) {
196				case 'c': case 'p': case 'u':
197					bcnt += 1;
198					break;
199				}
200			}
201		}
202		cursize += bcnt * fu->reps;
203	}
204	return (cursize);
205}
206
207void
208rewrite(FS *fs)
209{
210	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
211	PR *pr, **nextpr;
212	FU *fu;
213	unsigned char *p1, *p2, *fmtp;
214	char savech, cs[3];
215	int nconv, prec;
216
217	nextpr = NULL;
218	prec = 0;
219
220	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
221		/*
222		 * Break each format unit into print units; each conversion
223		 * character gets its own.
224		 */
225		for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
226			if ((pr = calloc(1, sizeof(PR))) == NULL)
227				err(1, NULL);
228			if (!fu->nextpr)
229				fu->nextpr = pr;
230			else
231				*nextpr = pr;
232
233			/* Skip preceding text and up to the next % sign. */
234			for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
235
236			/* Only text in the string. */
237			if (!*p1) {
238				pr->fmt = fmtp;
239				pr->flags = F_TEXT;
240				break;
241			}
242
243			/*
244			 * Get precision for %s -- if have a byte count, don't
245			 * need it.
246			 */
247			if (fu->bcnt) {
248				sokay = USEBCNT;
249				/* Skip to conversion character. */
250				for (++p1; index(spec, *p1); ++p1);
251			} else {
252				/* Skip any special chars, field width. */
253				while (index(spec + 1, *++p1));
254				if (*p1 == '.' && isdigit(*++p1)) {
255					sokay = USEPREC;
256					prec = atoi(p1);
257					while (isdigit(*++p1));
258				} else
259					sokay = NOTOKAY;
260			}
261
262			p2 = p1 + 1;		/* Set end pointer. */
263			cs[0] = *p1;		/* Set conversion string. */
264			cs[1] = '\0';
265
266			/*
267			 * Figure out the byte count for each conversion;
268			 * rewrite the format as necessary, set up blank-
269			 * padding for end of data.
270			 */
271			switch(cs[0]) {
272			case 'c':
273				pr->flags = F_CHAR;
274				switch(fu->bcnt) {
275				case 0: case 1:
276					pr->bcnt = 1;
277					break;
278				default:
279					p1[1] = '\0';
280					badcnt(p1);
281				}
282				break;
283			case 'd': case 'i':
284				pr->flags = F_INT;
285				goto isint;
286			case 'o': case 'u': case 'x': case 'X':
287				pr->flags = F_UINT;
288isint:				cs[2] = '\0';
289				cs[1] = cs[0];
290				cs[0] = 'q';
291				switch(fu->bcnt) {
292				case 0: case 4:
293					pr->bcnt = 4;
294					break;
295				case 1:
296					pr->bcnt = 1;
297					break;
298				case 2:
299					pr->bcnt = 2;
300					break;
301				default:
302					p1[1] = '\0';
303					badcnt(p1);
304				}
305				break;
306			case 'e': case 'E': case 'f': case 'g': case 'G':
307				pr->flags = F_DBL;
308				switch(fu->bcnt) {
309				case 0: case 8:
310					pr->bcnt = 8;
311					break;
312				case 4:
313					pr->bcnt = 4;
314					break;
315				default:
316					if (fu->bcnt == sizeof(long double)) {
317						cs[2] = '\0';
318						cs[1] = cs[0];
319						cs[0] = 'L';
320						pr->bcnt = sizeof(long double);
321					} else {
322						p1[1] = '\0';
323						badcnt(p1);
324					}
325				}
326				break;
327			case 's':
328				pr->flags = F_STR;
329				switch(sokay) {
330				case NOTOKAY:
331					badsfmt();
332				case USEBCNT:
333					pr->bcnt = fu->bcnt;
334					break;
335				case USEPREC:
336					pr->bcnt = prec;
337					break;
338				}
339				break;
340			case '_':
341				++p2;
342				switch(p1[1]) {
343				case 'A':
344					endfu = fu;
345					fu->flags |= F_IGNORE;
346					/* FALLTHROUGH */
347				case 'a':
348					pr->flags = F_ADDRESS;
349					++p2;
350					switch(p1[2]) {
351					case 'd': case 'o': case'x':
352						cs[0] = 'q';
353						cs[1] = p1[2];
354						cs[2] = '\0';
355						break;
356					default:
357						p1[3] = '\0';
358						badconv(p1);
359					}
360					break;
361				case 'c':
362					pr->flags = F_C;
363					/* cs[0] = 'c';	set in conv_c */
364					goto isint2;
365				case 'p':
366					pr->flags = F_P;
367					cs[0] = 'c';
368					goto isint2;
369				case 'u':
370					pr->flags = F_U;
371					/* cs[0] = 'c';	set in conv_u */
372isint2:					switch(fu->bcnt) {
373					case 0: case 1:
374						pr->bcnt = 1;
375						break;
376					default:
377						p1[2] = '\0';
378						badcnt(p1);
379					}
380					break;
381				default:
382					p1[2] = '\0';
383					badconv(p1);
384				}
385				break;
386			default:
387				p1[1] = '\0';
388				badconv(p1);
389			}
390
391			/*
392			 * Copy to PR format string, set conversion character
393			 * pointer, update original.
394			 */
395			savech = *p2;
396			p1[0] = '\0';
397			if ((pr->fmt = calloc(1, strlen(fmtp) + 2)) == NULL)
398				err(1, NULL);
399			(void)strcpy(pr->fmt, fmtp);
400			(void)strcat(pr->fmt, cs);
401			*p2 = savech;
402			pr->cchar = pr->fmt + (p1 - fmtp);
403			fmtp = p2;
404
405			/* Only one conversion character if byte count. */
406			if (!(pr->flags&F_ADDRESS) && fu->bcnt && nconv++)
407	    errx(1, "byte count with multiple conversion characters");
408		}
409		/*
410		 * If format unit byte count not specified, figure it out
411		 * so can adjust rep count later.
412		 */
413		if (!fu->bcnt)
414			for (pr = fu->nextpr; pr; pr = pr->nextpr)
415				fu->bcnt += pr->bcnt;
416	}
417	/*
418	 * If the format string interprets any data at all, and it's
419	 * not the same as the blocksize, and its last format unit
420	 * interprets any data at all, and has no iteration count,
421	 * repeat it as necessary.
422	 *
423	 * If, rep count is greater than 1, no trailing whitespace
424	 * gets output from the last iteration of the format unit.
425	 */
426	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
427		if (!fu->nextfu && fs->bcnt < blocksize &&
428		    !(fu->flags&F_SETREP) && fu->bcnt)
429			fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
430		if (fu->reps > 1) {
431			for (pr = fu->nextpr;; pr = pr->nextpr)
432				if (!pr->nextpr)
433					break;
434			for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
435				p2 = isspace(*p1) ? p1 : NULL;
436			if (p2)
437				pr->nospace = p2;
438		}
439	}
440#ifdef DEBUG
441	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
442		(void)printf("fmt:");
443		for (pr = fu->nextpr; pr; pr = pr->nextpr)
444			(void)printf(" {%s}", pr->fmt);
445		(void)printf("\n");
446	}
447#endif
448}
449
450void
451escape(char *p1)
452{
453	char *p2;
454
455	/* alphabetic escape sequences have to be done in place */
456	for (p2 = p1;; ++p1, ++p2) {
457		if (!*p1) {
458			*p2 = *p1;
459			break;
460		}
461		if (*p1 == '\\')
462			switch(*++p1) {
463			case 'a':
464			     /* *p2 = '\a'; */
465				*p2 = '\007';
466				break;
467			case 'b':
468				*p2 = '\b';
469				break;
470			case 'f':
471				*p2 = '\f';
472				break;
473			case 'n':
474				*p2 = '\n';
475				break;
476			case 'r':
477				*p2 = '\r';
478				break;
479			case 't':
480				*p2 = '\t';
481				break;
482			case 'v':
483				*p2 = '\v';
484				break;
485			default:
486				*p2 = *p1;
487				break;
488			}
489	}
490}
491
492void
493badcnt(char *s)
494{
495	errx(1, "%s: bad byte count", s);
496}
497
498void
499badsfmt(void)
500{
501	errx(1, "%%s: requires a precision or a byte count");
502}
503
504void
505badfmt(const char *fmt)
506{
507	errx(1, "\"%s\": bad format", fmt);
508}
509
510void
511badconv(char *ch)
512{
513	errx(1, "%%%s: bad conversion character", ch);
514}
515