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 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 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 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
Indexes created Sat Sep 20 22:09:52 GMT 2025