usr.bin/hexdump/odsyntax.c

   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 }