xref: /netbsd-src/usr.bin/hexdump/odsyntax.c (revision e45d81596048059cf412e70f3b6cfdf4cc643513)
1 /*	$NetBSD: odsyntax.c,v 1.28 2010/11/27 20:46:38 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 1990, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #if HAVE_NBTOOL_CONFIG_H
33 #include "nbtool_config.h"
34 #endif
35 
36 #include <sys/cdefs.h>
37 #if !defined(lint)
38 #if 0
39 static char sccsid[] = "@(#)odsyntax.c	8.2 (Berkeley) 5/4/95";
40 #else
41 __RCSID("$NetBSD: odsyntax.c,v 1.28 2010/11/27 20:46:38 christos Exp $");
42 #endif
43 #endif /* not lint */
44 
45 #include <sys/types.h>
46 
47 #include <ctype.h>
48 #include <err.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <unistd.h>
52 #include <util.h>
53 
54 #include "hexdump.h"
55 
56 #define PADDING "         "
57 
58 struct odformat {
59 	char type;
60 	int nbytes;
61 	char const *format;
62 	int minwidth;
63 };
64 
65 struct odaddrformat {
66 	char type;
67 	char const *format1;
68 	char const *format2;
69 };
70 
71 int odmode;
72 
73 static void odoffset(int, char ***);
74 static void posixtypes(char const *);
75 
76 void
odsyntax(int argc,char *** argvp)77 odsyntax(int argc, char ***argvp)
78 {
79 	static char empty[] = "", padding[] = PADDING;
80 	int ch;
81 	char *p, **argv;
82 
83 #define TYPE_OFFSET 7
84 	add("\"%07.7_Ao\n\"");
85 	add("\"%07.7_ao  \"");
86 
87 	odmode = 1;
88 	argv = *argvp;
89 	while ((ch = getopt(argc, argv,
90 	    "A:aBbcDdeFfHhIij:LlN:Oot:vXx")) != -1)
91 		switch (ch) {
92 		case 'A':
93 			switch (*optarg) {
94 			case 'd': case 'o': case 'x':
95 				fshead->nextfu->fmt[TYPE_OFFSET] = *optarg;
96 				fshead->nextfs->nextfu->fmt[TYPE_OFFSET] =
97 					*optarg;
98 				break;
99 			case 'n':
100 				fshead->nextfu->fmt = empty;
101 				fshead->nextfs->nextfu->fmt = padding;
102 				break;
103 			default:
104 				errx(1, "%s: invalid address base", optarg);
105 			}
106 			break;
107 		case 'a':
108 			posixtypes("a");
109 			break;
110 		case 'B':
111 		case 'o':
112 			posixtypes("o2");
113 			break;
114 		case 'b':
115 			posixtypes("o1");
116 			break;
117 		case 'c':
118 			posixtypes("c");
119 			break;
120 		case 'd':
121 			posixtypes("u2");
122 			break;
123 		case 'D':
124 			posixtypes("u4");
125 			break;
126 		case 'e':		/* undocumented in od */
127 		case 'F':
128 			posixtypes("f8");
129 			break;
130 		case 'f':
131 			posixtypes("f4");
132 			break;
133 		case 'H':
134 		case 'X':
135 			posixtypes("x4");
136 			break;
137 		case 'h':
138 		case 'x':
139 			posixtypes("x2");
140 			break;
141 		case 'I':
142 		case 'L':
143 		case 'l':
144 			posixtypes("d4");
145 			break;
146 		case 'i':
147 			posixtypes("d2");
148 			break;
149 		case 'j':
150 			if ((skip = strtol(optarg, &p, 0)) < 0)
151 				errx(1, "%s: bad skip value", optarg);
152 			switch(*p) {
153 			case 'b':
154 				skip *= 512;
155 				break;
156 			case 'k':
157 				skip *= 1024;
158 				break;
159 			case 'm':
160 				skip *= 1048576;
161 				break;
162 			}
163 			break;
164 		case 'N':
165 			if ((length = atoi(optarg)) < 0)
166 				errx(1, "%s: bad length value", optarg);
167 			break;
168 		case 'O':
169 			posixtypes("o4");
170 			break;
171 		case 't':
172 			posixtypes(optarg);
173 			break;
174 		case 'v':
175 			vflag = ALL;
176 			break;
177 		case '?':
178 		default:
179 			usage();
180 		}
181 
182 	if (fshead->nextfs->nextfs == NULL)
183 		posixtypes("oS");
184 
185 	argc -= optind;
186 	*argvp += optind;
187 
188 	if (argc)
189 		odoffset(argc, argvp);
190 }
191 
192 /* formats used for -t */
193 
194 static const struct odformat odftab[] = {
195 	{ 'a', 1, "%3_u",  4 },
196 	{ 'c', 1, "%3_c",  4 },
197 	{ 'd', 1, "%4d",   5 },
198 	{ 'd', 2, "%6d",   6 },
199 	{ 'd', 4, "%11d", 11 },
200 	{ 'd', 8, "%20d", 20 },
201 	{ 'o', 1, "%03o",  4 },
202 	{ 'o', 2, "%06o",  7 },
203 	{ 'o', 4, "%011o", 12 },
204 	{ 'o', 8, "%022o", 23 },
205 	{ 'u', 1, "%03u" , 4 },
206 	{ 'u', 2, "%05u" , 6 },
207 	{ 'u', 4, "%010u", 11 },
208 	{ 'u', 8, "%020u", 21 },
209 	{ 'x', 1, "%02x",  3 },
210 	{ 'x', 2, "%04x",  5 },
211 	{ 'x', 4, "%08x",  9 },
212 	{ 'x', 8, "%016x", 17 },
213 	{ 'f', 4, "%14.7e",  15 },
214 	{ 'f', 8, "%21.14e", 22 },
215 	{ 0, 0, NULL, 0 }
216 };
217 
218 /*
219  * Interpret a POSIX-style -t argument.
220  */
221 static void
posixtypes(char const * type_string)222 posixtypes(char const *type_string)
223 {
224 	int nbytes = 0;
225 	char *fmt, type, *tmp;
226 	struct odformat const *odf;
227 
228 	while (*type_string) {
229 		switch ((type = *type_string++)) {
230 		case 'a':
231 		case 'c':
232 			nbytes = 1;
233 			break;
234 		case 'f':
235 			if (isupper((unsigned char)*type_string)) {
236 				switch(*type_string) {
237 				case 'F':
238 					nbytes = sizeof(float);
239 					break;
240 				case 'D':
241 					nbytes = sizeof(double);
242 					break;
243 				case 'L':
244 					nbytes = sizeof(long double);
245 					break;
246 				default:
247 					warnx("Bad type-size qualifier '%c'",
248 					    *type_string);
249 					usage();
250 				}
251 				type_string++;
252 			} else if (isdigit((unsigned char)*type_string)) {
253 				nbytes = strtol(type_string, &tmp, 10);
254 				type_string = tmp;
255 			} else
256 				nbytes = 8;
257 			break;
258 		case 'd':
259 		case 'o':
260 		case 'u':
261 		case 'x':
262 			if (isupper((unsigned char)*type_string)) {
263 				switch(*type_string) {
264 				case 'C':
265 					nbytes = sizeof(char);
266 					break;
267 				case 'S':
268 					nbytes = sizeof(short);
269 					break;
270 				case 'I':
271 					nbytes = sizeof(int);
272 					break;
273 				case 'L':
274 					nbytes = sizeof(long);
275 					break;
276 				default:
277 					warnx("Bad type-size qualifier '%c'",
278 					    *type_string);
279 					usage();
280 				}
281 				type_string++;
282 			} else if (isdigit((unsigned char)*type_string)) {
283 				nbytes = strtol(type_string, &tmp, 10);
284 				type_string = tmp;
285 			} else
286 				nbytes = 4;
287 			break;
288 		default:
289 			usage();
290 		}
291 		for (odf = odftab; odf->type != 0; odf++)
292 			if (odf->type == type && odf->nbytes == nbytes)
293 				break;
294 		if (odf->type == 0)
295 			errx(1, "%c%d: format not supported", type, nbytes);
296 		(void)easprintf(&fmt, "%d/%d  \"%*s%s \" \"\\n\"",
297 		    16 / nbytes, nbytes,
298 		    4 * nbytes - odf->minwidth, "", odf->format);
299 		add(fmt);
300 	}
301 }
302 
303 static void
odoffset(int argc,char *** argvp)304 odoffset(int argc, char ***argvp)
305 {
306 	char *num, *p;
307 	int base;
308 	char *end;
309 
310 	/*
311 	 * The offset syntax of od(1) was genuinely bizarre.  First, if
312 	 * it started with a plus it had to be an offset.  Otherwise, if
313 	 * there were at least two arguments, a number or lower-case 'x'
314 	 * followed by a number makes it an offset.  By default it was
315 	 * octal; if it started with 'x' or '0x' it was hex.  If it ended
316 	 * in a '.', it was decimal.  If a 'b' or 'B' was appended, it
317 	 * multiplied the number by 512 or 1024 byte units.  There was
318 	 * no way to assign a block count to a hex offset.
319 	 *
320 	 * We assume it's a file if the offset is bad.
321 	 */
322 	p = argc == 1 ? (*argvp)[0] : (*argvp)[1];
323 	if (!p)
324 		return;
325 
326 	if (*p != '+' && (argc < 2 ||
327 	    (!isdigit((unsigned char)p[0]) &&
328 	    (p[0] != 'x' || !isxdigit((unsigned char)p[1])))))
329 		return;
330 
331 	base = 0;
332 	/*
333 	 * skip over leading '+', 'x[0-9a-fA-f]' or '0x', and
334 	 * set base.
335 	 */
336 	if (p[0] == '+')
337 		++p;
338 	if (p[0] == 'x' && isxdigit((unsigned char)p[1])) {
339 		++p;
340 		base = 16;
341 	} else if (p[0] == '0' && p[1] == 'x') {
342 		p += 2;
343 		base = 16;
344 	}
345 
346 	/* skip over the number */
347 	if (base == 16)
348 		for (num = p; isxdigit((unsigned char)*p); ++p);
349 	else
350 		for (num = p; isdigit((unsigned char)*p); ++p);
351 
352 	/* check for no number */
353 	if (num == p)
354 		return;
355 
356 	/* if terminates with a '.', base is decimal */
357 	if (*p == '.') {
358 		if (base)
359 			return;
360 		base = 10;
361 	}
362 
363 	skip = strtol(num, &end, base ? base : 8);
364 
365 	/* if end isn't the same as p, we got a non-octal digit */
366 	if (end != p) {
367 		skip = 0;
368 		return;
369 	}
370 
371 	if (*p) {
372 		if (*p == 'B') {
373 			skip *= 1024;
374 			++p;
375 		} else if (*p == 'b') {
376 			skip *= 512;
377 			++p;
378 		}
379 	}
380 	if (*p) {
381 		skip = 0;
382 		return;
383 	}
384 	/*
385 	 * If the offset uses a non-octal base, the base of the offset
386 	 * is changed as well.  This isn't pretty, but it's easy.
387 	 */
388 	if (base == 16) {
389 		fshead->nextfu->fmt[TYPE_OFFSET] = 'x';
390 		fshead->nextfs->nextfu->fmt[TYPE_OFFSET] = 'x';
391 	} else if (base == 10) {
392 		fshead->nextfu->fmt[TYPE_OFFSET] = 'd';
393 		fshead->nextfs->nextfu->fmt[TYPE_OFFSET] = 'd';
394 	}
395 
396 	/* Terminate file list. */
397 	(*argvp)[1] = NULL;
398 }
399