xref: /freebsd/usr.bin/hexdump/parse.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
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
36 static char sccsid[] = "@(#)parse.c	8.1 (Berkeley) 6/6/93";
37 #endif
38 #endif /* not lint */
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD$");
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 
52 FU *endfu;					/* format at end-of-data */
53 
54 void
55 addfile(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 
79 void
80 add(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) strlcpy(tfu->fmt, savep, p - savep + 1);
146 		escape(tfu->fmt);
147 		p++;
148 	}
149 }
150 
151 static const char *spec = ".#-+ 0123456789";
152 
153 int
154 size(FS *fs)
155 {
156 	FU *fu;
157 	int bcnt, cursize;
158 	unsigned char *fmt;
159 	int prec;
160 
161 	/* figure out the data block size needed for each format unit */
162 	for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
163 		if (fu->bcnt) {
164 			cursize += fu->bcnt * fu->reps;
165 			continue;
166 		}
167 		for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
168 			if (*fmt != '%')
169 				continue;
170 			/*
171 			 * skip any special chars -- save precision in
172 			 * case it's a %s format.
173 			 */
174 			while (index(spec + 1, *++fmt));
175 			if (*fmt == '.' && isdigit(*++fmt)) {
176 				prec = atoi(fmt);
177 				while (isdigit(*++fmt));
178 			}
179 			switch(*fmt) {
180 			case 'c':
181 				bcnt += 1;
182 				break;
183 			case 'd': case 'i': case 'o': case 'u':
184 			case 'x': case 'X':
185 				bcnt += 4;
186 				break;
187 			case 'e': case 'E': case 'f': case 'g': case 'G':
188 				bcnt += 8;
189 				break;
190 			case 's':
191 				bcnt += prec;
192 				break;
193 			case '_':
194 				switch(*++fmt) {
195 				case 'c': case 'p': case 'u':
196 					bcnt += 1;
197 					break;
198 				}
199 			}
200 		}
201 		cursize += bcnt * fu->reps;
202 	}
203 	return (cursize);
204 }
205 
206 void
207 rewrite(FS *fs)
208 {
209 	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
210 	PR *pr, **nextpr;
211 	FU *fu;
212 	unsigned char *p1, *p2, *fmtp;
213 	char savech, cs[3];
214 	int nconv, prec;
215 	size_t len;
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;
288 isint:				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 */
372 isint2:					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 			len = strlen(fmtp) + strlen(cs) + 1;
398 			if ((pr->fmt = calloc(1, len)) == NULL)
399 				err(1, NULL);
400 			snprintf(pr->fmt, len, "%s%s", fmtp, 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 
450 void
451 escape(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 
492 void
493 badcnt(char *s)
494 {
495 	errx(1, "%s: bad byte count", s);
496 }
497 
498 void
499 badsfmt(void)
500 {
501 	errx(1, "%%s: requires a precision or a byte count");
502 }
503 
504 void
505 badfmt(const char *fmt)
506 {
507 	errx(1, "\"%s\": bad format", fmt);
508 }
509 
510 void
511 badconv(char *ch)
512 {
513 	errx(1, "%%%s: bad conversion character", ch);
514 }
515