pintos-os.org Git - pspp/blob - utilities/pspp-dump-sav.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <getopt.h>
  22 #include <inttypes.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "data/val-type.h"
  28 #include "libpspp/cast.h"
  29 #include "libpspp/compiler.h"
  30 #include "libpspp/float-format.h"
  31 #include "libpspp/integer-format.h"
  32 #include "libpspp/misc.h"
  33
  34 #include "gl/error.h"
  35 #include "gl/minmax.h"
  36 #include "gl/progname.h"
  37 #include "gl/version-etc.h"
  38 #include "gl/xalloc.h"
  39
  40 #define ID_MAX_LEN 64
  41
  42 struct sfm_reader
  43   {
  44     const char *file_name;
  45     FILE *file;
  46
  47     int n_variable_records, n_variables;
  48
  49     int *var_widths;
  50     size_t n_var_widths, allocated_var_widths;
  51
  52     enum integer_format integer_format;
  53     enum float_format float_format;
  54
  55     bool compressed;
  56     double bias;
  57   };
  58
  59 static void read_header (struct sfm_reader *);
  60 static void read_variable_record (struct sfm_reader *);
  61 static void read_value_label_record (struct sfm_reader *);
  62 static void read_document_record (struct sfm_reader *);
  63 static void read_extension_record (struct sfm_reader *);
  64 static void read_machine_integer_info (struct sfm_reader *,
  65                                        size_t size, size_t count);
  66 static void read_machine_float_info (struct sfm_reader *,
  67                                      size_t size, size_t count);
  68 static void read_extra_product_info (struct sfm_reader *,
  69                                      size_t size, size_t count);
  70 static void read_mrsets (struct sfm_reader *, size_t size, size_t count);
  71 static void read_display_parameters (struct sfm_reader *,
  72                                      size_t size, size_t count);
  73 static void read_long_var_name_map (struct sfm_reader *r,
  74                                     size_t size, size_t count);
  75 static void read_long_string_map (struct sfm_reader *r,
  76                                   size_t size, size_t count);
  77 static void read_datafile_attributes (struct sfm_reader *r,
  78                                       size_t size, size_t count);
  79 static void read_variable_attributes (struct sfm_reader *r,
  80                                       size_t size, size_t count);
  81 static void read_ncases64 (struct sfm_reader *, size_t size, size_t count);
  82 static void read_character_encoding (struct sfm_reader *r,
  83                                        size_t size, size_t count);
  84 static void read_long_string_value_labels (struct sfm_reader *r,
  85                                            size_t size, size_t count);
  86 static void read_long_string_missing_values (struct sfm_reader *r,
  87                                              size_t size, size_t count);
  88 static void read_unknown_extension (struct sfm_reader *,
  89                                     size_t size, size_t count);
  90 static void read_compressed_data (struct sfm_reader *, int max_cases);
  91
  92 static struct text_record *open_text_record (
  93   struct sfm_reader *, size_t size);
  94 static void close_text_record (struct text_record *);
  95 static bool read_variable_to_value_pair (struct text_record *,
  96                                          char **key, char **value);
  97 static char *text_tokenize (struct text_record *, int delimiter);
  98 static bool text_match (struct text_record *text, int c);
  99 static const char *text_parse_counted_string (struct text_record *);
 100 static size_t text_pos (const struct text_record *);
 101 static const char *text_get_all (const struct text_record *);
 102
 103 static void usage (void);
 104 static void sys_warn (struct sfm_reader *, const char *, ...)
 105      PRINTF_FORMAT (2, 3);
 106 static void sys_error (struct sfm_reader *, const char *, ...)
 107      PRINTF_FORMAT (2, 3)
 108      NO_RETURN;
 109
 110 static void read_bytes (struct sfm_reader *, void *, size_t);
 111 static bool try_read_bytes (struct sfm_reader *, void *, size_t);
 112 static int read_int (struct sfm_reader *);
 113 static int64_t read_int64 (struct sfm_reader *);
 114 static double read_float (struct sfm_reader *);
 115 static void read_string (struct sfm_reader *, char *, size_t);
 116 static void skip_bytes (struct sfm_reader *, size_t);
 117 static void trim_spaces (char *);
 118
 119 static void print_string (const char *s, size_t len);
 120
 121 int
 122 main (int argc, char *argv[])
 123 {
 124   int max_cases = 0;
 125   struct sfm_reader r;
 126   int i;
 127
 128   set_program_name (argv[0]);
 129
 130   for (;;)
 131     {
 132       static const struct option long_options[] =
 133         {
 134           { "data",    optional_argument, NULL, 'd' },
 135           { "help",    no_argument,       NULL, 'h' },
 136           { "version", no_argument,       NULL, 'v' },
 137           { NULL,      0,                 NULL, 0 },
 138         };
 139
 140       int c;
 141
 142       c = getopt_long (argc, argv, "d::hv", long_options, NULL);
 143       if (c == -1)
 144         break;
 145
 146       switch (c)
 147         {
 148         case 'd':
 149           max_cases = optarg ? atoi (optarg) : INT_MAX;
 150           break;
 151
 152         case 'v':
 153           version_etc (stdout, "pspp-dump-sav", PACKAGE_NAME, PACKAGE_VERSION,
 154                        "Ben Pfaff", "John Darrington", NULL_SENTINEL);
 155           exit (EXIT_SUCCESS);
 156
 157         case 'h':
 158           usage ();
 159           exit (EXIT_SUCCESS);
 160
 161         default:
 162           exit (EXIT_FAILURE);
 163         }
 164     }
 165
 166   if (optind == argc)
 167     error (1, 0, "at least one non-option argument is required; "
 168            "use --help for help");
 169
 170   for (i = optind; i < argc; i++)
 171     {
 172       int rec_type;
 173
 174       r.file_name = argv[i];
 175       r.file = fopen (r.file_name, "rb");
 176       if (r.file == NULL)
 177         error (EXIT_FAILURE, errno, "error opening `%s'", r.file_name);
 178       r.n_variable_records = 0;
 179       r.n_variables = 0;
 180       r.n_var_widths = 0;
 181       r.allocated_var_widths = 0;
 182       r.var_widths = 0;
 183       r.compressed = false;
 184
 185       if (argc - optind > 1)
 186         printf ("Reading \"%s\":\n", r.file_name);
 187
 188       read_header (&r);
 189       while ((rec_type = read_int (&r)) != 999)
 190         {
 191           switch (rec_type)
 192             {
 193             case 2:
 194               read_variable_record (&r);
 195               break;
 196
 197             case 3:
 198               read_value_label_record (&r);
 199               break;
 200
 201             case 4:
 202               sys_error (&r, "Misplaced type 4 record.");
 203
 204             case 6:
 205               read_document_record (&r);
 206               break;
 207
 208             case 7:
 209               read_extension_record (&r);
 210               break;
 211
 212             default:
 213               sys_error (&r, "Unrecognized record type %d.", rec_type);
 214             }
 215         }
 216       printf ("%08llx: end-of-dictionary record "
 217               "(first byte of data at %08llx)\n",
 218               (long long int) ftello (r.file),
 219               (long long int) ftello (r.file) + 4);
 220
 221       if (r.compressed && max_cases > 0)
 222         read_compressed_data (&r, max_cases);
 223
 224       fclose (r.file);
 225     }
 226
 227   return 0;
 228 }
 229
 230 static void
 231 read_header (struct sfm_reader *r)
 232 {
 233   char rec_type[5];
 234   char eye_catcher[61];
 235   uint8_t raw_layout_code[4];
 236   int32_t layout_code;
 237   int32_t compressed;
 238   int32_t weight_index;
 239   int32_t ncases;
 240   uint8_t raw_bias[8];
 241   char creation_date[10];
 242   char creation_time[9];
 243   char file_label[65];
 244
 245   read_string (r, rec_type, sizeof rec_type);
 246   read_string (r, eye_catcher, sizeof eye_catcher);
 247
 248   if (strcmp ("$FL2", rec_type) != 0)
 249     sys_error (r, "This is not an SPSS system file.");
 250
 251   /* Identify integer format. */
 252   read_bytes (r, raw_layout_code, sizeof raw_layout_code);
 253   if ((!integer_identify (2, raw_layout_code, sizeof raw_layout_code,
 254                           &r->integer_format)
 255        && !integer_identify (3, raw_layout_code, sizeof raw_layout_code,
 256                              &r->integer_format))
 257       || (r->integer_format != INTEGER_MSB_FIRST
 258           && r->integer_format != INTEGER_LSB_FIRST))
 259     sys_error (r, "This is not an SPSS system file.");
 260   layout_code = integer_get (r->integer_format,
 261                              raw_layout_code, sizeof raw_layout_code);
 262
 263   read_int (r);                 /* Nominal case size (not actually useful). */
 264   compressed = read_int (r);
 265   weight_index = read_int (r);
 266   ncases = read_int (r);
 267
 268   r->compressed = compressed != 0;
 269
 270   /* Identify floating-point format and obtain compression bias. */
 271   read_bytes (r, raw_bias, sizeof raw_bias);
 272   if (float_identify (100.0, raw_bias, sizeof raw_bias, &r->float_format) == 0)
 273     {
 274       sys_warn (r, "Compression bias is not the usual value of 100, or system "
 275                 "file uses unrecognized floating-point format.");
 276       if (r->integer_format == INTEGER_MSB_FIRST)
 277         r->float_format = FLOAT_IEEE_DOUBLE_BE;
 278       else
 279         r->float_format = FLOAT_IEEE_DOUBLE_LE;
 280     }
 281   r->bias = float_get_double (r->float_format, raw_bias);
 282
 283   read_string (r, creation_date, sizeof creation_date);
 284   read_string (r, creation_time, sizeof creation_time);
 285   read_string (r, file_label, sizeof file_label);
 286   trim_spaces (file_label);
 287   skip_bytes (r, 3);
 288
 289   printf ("File header record:\n");
 290   printf ("\t%17s: %s\n", "Product name", eye_catcher);
 291   printf ("\t%17s: %"PRId32"\n", "Layout code", layout_code);
 292   printf ("\t%17s: %"PRId32"\n", "Compressed", compressed);
 293   printf ("\t%17s: %"PRId32"\n", "Weight index", weight_index);
 294   printf ("\t%17s: %"PRId32"\n", "Number of cases", ncases);
 295   printf ("\t%17s: %g\n", "Compression bias", r->bias);
 296   printf ("\t%17s: %s\n", "Creation date", creation_date);
 297   printf ("\t%17s: %s\n", "Creation time", creation_time);
 298   printf ("\t%17s: \"%s\"\n", "File label", file_label);
 299 }
 300
 301 static const char *
 302 format_name (int format)
 303 {
 304   switch ((format >> 16) & 0xff)
 305     {
 306     case 1: return "A";
 307     case 2: return "AHEX";
 308     case 3: return "COMMA";
 309     case 4: return "DOLLAR";
 310     case 5: return "F";
 311     case 6: return "IB";
 312     case 7: return "PIBHEX";
 313     case 8: return "P";
 314     case 9: return "PIB";
 315     case 10: return "PK";
 316     case 11: return "RB";
 317     case 12: return "RBHEX";
 318     case 15: return "Z";
 319     case 16: return "N";
 320     case 17: return "E";
 321     case 20: return "DATE";
 322     case 21: return "TIME";
 323     case 22: return "DATETIME";
 324     case 23: return "ADATE";
 325     case 24: return "JDATE";
 326     case 25: return "DTIME";
 327     case 26: return "WKDAY";
 328     case 27: return "MONTH";
 329     case 28: return "MOYR";
 330     case 29: return "QYR";
 331     case 30: return "WKYR";
 332     case 31: return "PCT";
 333     case 32: return "DOT";
 334     case 33: return "CCA";
 335     case 34: return "CCB";
 336     case 35: return "CCC";
 337     case 36: return "CCD";
 338     case 37: return "CCE";
 339     case 38: return "EDATE";
 340     case 39: return "SDATE";
 341     default: return "invalid";
 342     }
 343 }
 344
 345 /* Reads a variable (type 2) record from R and adds the
 346    corresponding variable to DICT.
 347    Also skips past additional variable records for long string
 348    variables. */
 349 static void
 350 read_variable_record (struct sfm_reader *r)
 351 {
 352   int width;
 353   int has_variable_label;
 354   int missing_value_code;
 355   int print_format;
 356   int write_format;
 357   char name[9];
 358
 359   printf ("%08llx: variable record #%d\n",
 360           (long long int) ftello (r->file), r->n_variable_records++);
 361
 362   width = read_int (r);
 363   has_variable_label = read_int (r);
 364   missing_value_code = read_int (r);
 365   print_format = read_int (r);
 366   write_format = read_int (r);
 367   read_string (r, name, sizeof name);
 368   name[strcspn (name, " ")] = '\0';
 369
 370   if (width >= 0)
 371     r->n_variables++;
 372
 373   if (r->n_var_widths >= r->allocated_var_widths)
 374     r->var_widths = x2nrealloc (r->var_widths, &r->allocated_var_widths,
 375                                 sizeof *r->var_widths);
 376   r->var_widths[r->n_var_widths++] = width;
 377
 378   printf ("\tWidth: %d (%s)\n",
 379           width,
 380           width > 0 ? "string"
 381           : width == 0 ? "numeric"
 382           : "long string continuation record");
 383   printf ("\tVariable label: %d\n", has_variable_label);
 384   printf ("\tMissing values code: %d (%s)\n", missing_value_code,
 385           (missing_value_code == 0 ? "no missing values"
 386            : missing_value_code == 1 ? "one missing value"
 387            : missing_value_code == 2 ? "two missing values"
 388            : missing_value_code == 3 ? "three missing values"
 389            : missing_value_code == -2 ? "one missing value range"
 390            : missing_value_code == -3 ? "one missing value, one range"
 391            : "bad value"));
 392   printf ("\tPrint format: %06x (%s%d.%d)\n",
 393           print_format, format_name (print_format),
 394           (print_format >> 8) & 0xff, print_format & 0xff);
 395   printf ("\tWrite format: %06x (%s%d.%d)\n",
 396           write_format, format_name (write_format),
 397           (write_format >> 8) & 0xff, write_format & 0xff);
 398   printf ("\tName: %s\n", name);
 399
 400   /* Get variable label, if any. */
 401   if (has_variable_label != 0 && has_variable_label != 1)
 402     sys_error (r, "Variable label indicator field is not 0 or 1.");
 403   if (has_variable_label == 1)
 404     {
 405       long long int offset = ftello (r->file);
 406       size_t len, read_len;
 407       char label[255 + 1];
 408
 409       len = read_int (r);
 410
 411       /* Read up to 255 bytes of label. */
 412       read_len = MIN (sizeof label - 1, len);
 413       read_string (r, label, read_len + 1);
 414       printf("\t%08llx Variable label: \"%s\"\n", offset, label);
 415
 416       /* Skip unread label bytes. */
 417       skip_bytes (r, len - read_len);
 418
 419       /* Skip label padding up to multiple of 4 bytes. */
 420       skip_bytes (r, ROUND_UP (len, 4) - len);
 421     }
 422
 423   /* Set missing values. */
 424   if (missing_value_code != 0)
 425     {
 426       int i;
 427
 428       printf ("\t%08llx Missing values:", (long long int) ftello (r->file));
 429       if (!width)
 430         {
 431           if (missing_value_code < -3 || missing_value_code > 3
 432               || missing_value_code == -1)
 433             sys_error (r, "Numeric missing value indicator field is not "
 434                        "-3, -2, 0, 1, 2, or 3.");
 435           if (missing_value_code < 0)
 436             {
 437               double low = read_float (r);
 438               double high = read_float (r);
 439               printf (" %g...%g", low, high);
 440               missing_value_code = -missing_value_code - 2;
 441             }
 442           for (i = 0; i < missing_value_code; i++)
 443             printf (" %g", read_float (r));
 444         }
 445       else if (width > 0)
 446         {
 447           if (missing_value_code < 1 || missing_value_code > 3)
 448             sys_error (r, "String missing value indicator field is not "
 449                        "0, 1, 2, or 3.");
 450           for (i = 0; i < missing_value_code; i++)
 451             {
 452               char string[9];
 453               read_string (r, string, sizeof string);
 454               printf (" \"%s\"", string);
 455             }
 456         }
 457       putchar ('\n');
 458     }
 459 }
 460
 461 static void
 462 print_untyped_value (struct sfm_reader *r, char raw_value[8])
 463 {
 464   int n_printable;
 465   double value;
 466
 467   value = float_get_double (r->float_format, raw_value);
 468   for (n_printable = 0; n_printable < 8; n_printable++)
 469     if (!isprint (raw_value[n_printable]))
 470       break;
 471
 472   printf ("%g/\"%.*s\"", value, n_printable, raw_value);
 473 }
 474
 475 /* Reads value labels from sysfile R and inserts them into the
 476    associated dictionary. */
 477 static void
 478 read_value_label_record (struct sfm_reader *r)
 479 {
 480   int label_cnt, var_cnt;
 481   int i;
 482
 483   printf ("%08llx: value labels record\n", (long long int) ftello (r->file));
 484
 485   /* Read number of labels. */
 486   label_cnt = read_int (r);
 487   for (i = 0; i < label_cnt; i++)
 488     {
 489       char raw_value[8];
 490       unsigned char label_len;
 491       size_t padded_len;
 492       char label[256];
 493
 494       read_bytes (r, raw_value, sizeof raw_value);
 495
 496       /* Read label length. */
 497       read_bytes (r, &label_len, sizeof label_len);
 498       padded_len = ROUND_UP (label_len + 1, 8);
 499
 500       /* Read label, padding. */
 501       read_bytes (r, label, padded_len - 1);
 502       label[label_len] = 0;
 503
 504       printf ("\t");
 505       print_untyped_value (r, raw_value);
 506       printf (": \"%s\"\n", label);
 507     }
 508
 509   /* Now, read the type 4 record that has the list of variables
 510      to which the value labels are to be applied. */
 511
 512   /* Read record type of type 4 record. */
 513   if (read_int (r) != 4)
 514     sys_error (r, "Variable index record (type 4) does not immediately "
 515                "follow value label record (type 3) as it should.");
 516
 517   /* Read number of variables associated with value label from type 4
 518      record. */
 519   printf ("\t%08llx: apply to variables", (long long int) ftello (r->file));
 520   var_cnt = read_int (r);
 521   for (i = 0; i < var_cnt; i++)
 522     printf (" #%d", read_int (r));
 523   putchar ('\n');
 524 }
 525
 526 static void
 527 read_document_record (struct sfm_reader *r)
 528 {
 529   int n_lines;
 530   int i;
 531
 532   printf ("%08llx: document record\n", (long long int) ftello (r->file));
 533   n_lines = read_int (r);
 534   printf ("\t%d lines of documents\n", n_lines);
 535
 536   for (i = 0; i < n_lines; i++)
 537     {
 538       char line[81];
 539       printf ("\t%08llx: ", (long long int) ftello (r->file));
 540       read_string (r, line, sizeof line);
 541       trim_spaces (line);
 542       printf ("line %d: \"%s\"\n", i, line);
 543     }
 544 }
 545
 546 static void
 547 read_extension_record (struct sfm_reader *r)
 548 {
 549   long long int offset = ftello (r->file);
 550   int subtype = read_int (r);
 551   size_t size = read_int (r);
 552   size_t count = read_int (r);
 553   size_t bytes = size * count;
 554
 555   printf ("%08llx: Record 7, subtype %d, size=%zu, count=%zu\n",
 556           offset, subtype, size, count);
 557
 558   switch (subtype)
 559     {
 560     case 3:
 561       read_machine_integer_info (r, size, count);
 562       return;
 563
 564     case 4:
 565       read_machine_float_info (r, size, count);
 566       return;
 567
 568     case 5:
 569       /* Variable sets information.  We don't use these yet.
 570          They only apply to GUIs; see VARSETS on the APPLY
 571          DICTIONARY command in SPSS documentation. */
 572       break;
 573
 574     case 6:
 575       /* DATE variable information.  We don't use it yet, but we
 576          should. */
 577       break;
 578
 579     case 7:
 580     case 19:
 581       read_mrsets (r, size, count);
 582       return;
 583
 584     case 10:
 585       read_extra_product_info (r, size, count);
 586       return;
 587
 588     case 11:
 589       read_display_parameters (r, size, count);
 590       return;
 591
 592     case 13:
 593       read_long_var_name_map (r, size, count);
 594       return;
 595
 596     case 14:
 597       read_long_string_map (r, size, count);
 598       return;
 599
 600     case 16:
 601       read_ncases64 (r, size, count);
 602       return;
 603
 604     case 17:
 605       read_datafile_attributes (r, size, count);
 606       return;
 607
 608     case 18:
 609       read_variable_attributes (r, size, count);
 610       return;
 611
 612     case 20:
 613       read_character_encoding (r, size, count);
 614       return;
 615
 616     case 21:
 617       read_long_string_value_labels (r, size, count);
 618       return;
 619
 620     case 22:
 621       read_long_string_missing_values (r, size, count);
 622       return;
 623
 624     default:
 625       sys_warn (r, "Unrecognized record type 7, subtype %d.", subtype);
 626       read_unknown_extension (r, size, count);
 627       return;
 628     }
 629
 630   skip_bytes (r, bytes);
 631 }
 632
 633 static void
 634 read_machine_integer_info (struct sfm_reader *r, size_t size, size_t count)
 635 {
 636   long long int offset = ftello (r->file);
 637   int version_major = read_int (r);
 638   int version_minor = read_int (r);
 639   int version_revision = read_int (r);
 640   int machine_code = read_int (r);
 641   int float_representation = read_int (r);
 642   int compression_code = read_int (r);
 643   int integer_representation = read_int (r);
 644   int character_code = read_int (r);
 645
 646   printf ("%08llx: machine integer info\n", offset);
 647   if (size != 4 || count != 8)
 648     sys_error (r, "Bad size (%zu) or count (%zu) field on record type 7, "
 649                "subtype 3.", size, count);
 650
 651   printf ("\tVersion: %d.%d.%d\n",
 652           version_major, version_minor, version_revision);
 653   printf ("\tMachine code: %d\n", machine_code);
 654   printf ("\tFloating point representation: %d (%s)\n",
 655           float_representation,
 656           float_representation == 1 ? "IEEE 754"
 657           : float_representation == 2 ? "IBM 370"
 658           : float_representation == 3 ? "DEC VAX"
 659           : "unknown");
 660   printf ("\tCompression code: %d\n", compression_code);
 661   printf ("\tEndianness: %d (%s)\n", integer_representation,
 662           integer_representation == 1 ? "big"
 663           : integer_representation == 2 ? "little" : "unknown");
 664   printf ("\tCharacter code: %d\n", character_code);
 665 }
 666
 667 /* Read record type 7, subtype 4. */
 668 static void
 669 read_machine_float_info (struct sfm_reader *r, size_t size, size_t count)
 670 {
 671   long long int offset = ftello (r->file);
 672   double sysmis = read_float (r);
 673   double highest = read_float (r);
 674   double lowest = read_float (r);
 675
 676   printf ("%08llx: machine float info\n", offset);
 677   if (size != 8 || count != 3)
 678     sys_error (r, "Bad size (%zu) or count (%zu) on extension 4.",
 679                size, count);
 680
 681   printf ("\tsysmis: %g (%a)\n", sysmis, sysmis);
 682   if (sysmis != SYSMIS)
 683     sys_warn (r, "File specifies unexpected value %g (%a) as %s.",
 684               sysmis, sysmis, "SYSMIS");
 685
 686   printf ("\thighest: %g (%a)\n", highest, highest);
 687   if (highest != HIGHEST)
 688     sys_warn (r, "File specifies unexpected value %g (%a) as %s.",
 689               highest, highest, "HIGHEST");
 690
 691   printf ("\tlowest: %g (%a)\n", lowest, lowest);
 692   if (lowest != LOWEST && lowest != SYSMIS)
 693     sys_warn (r, "File specifies unexpected value %g (%a) as %s.",
 694               lowest, lowest, "LOWEST");
 695 }
 696
 697 static void
 698 read_extra_product_info (struct sfm_reader *r,
 699                          size_t size, size_t count)
 700 {
 701   struct text_record *text;
 702   const char *s;
 703
 704   printf ("%08llx: extra product info\n", (long long int) ftello (r->file));
 705   text = open_text_record (r, size * count);
 706   s = text_get_all (text);
 707   print_string (s, strlen (s));
 708   close_text_record (text);
 709 }
 710
 711 /* Read record type 7, subtype 7. */
 712 static void
 713 read_mrsets (struct sfm_reader *r, size_t size, size_t count)
 714 {
 715   struct text_record *text;
 716
 717   printf ("%08llx: multiple response sets\n",
 718           (long long int) ftello (r->file));
 719   text = open_text_record (r, size * count);
 720   for (;;)
 721     {
 722       const char *name;
 723       enum { MRSET_MC, MRSET_MD } type;
 724       bool cat_label_from_counted_values = false;
 725       bool label_from_var_label = false;
 726       const char *counted;
 727       const char *label;
 728       const char *variables;
 729
 730       name = text_tokenize (text, '=');
 731       if (name == NULL)
 732         break;
 733
 734       if (text_match (text, 'C'))
 735         {
 736           type = MRSET_MC;
 737           counted = NULL;
 738           if (!text_match (text, ' '))
 739             {
 740               sys_warn (r, "missing space following 'C' at offset %zu "
 741                         "in mrsets record", text_pos (text));
 742               break;
 743             }
 744         }
 745       else if (text_match (text, 'D'))
 746         {
 747           type = MRSET_MD;
 748         }
 749       else if (text_match (text, 'E'))
 750         {
 751           char *number;
 752
 753           type = MRSET_MD;
 754           cat_label_from_counted_values = true;
 755
 756           if (!text_match (text, ' '))
 757             {
 758               sys_warn (r, "Missing space following `%c' at offset %zu "
 759                         "in MRSETS record", 'E', text_pos (text));
 760               break;
 761             }
 762
 763           number = text_tokenize (text, ' ');
 764           if (!strcmp (number, "11"))
 765             label_from_var_label = true;
 766           else if (strcmp (number, "1"))
 767             sys_warn (r, "Unexpected label source value `%s' "
 768                       "following `E' at offset %zu in MRSETS record",
 769                       number, text_pos (text));
 770
 771         }
 772       else
 773         {
 774           sys_warn (r, "missing `C', `D', or `E' at offset %zu "
 775                     "in mrsets record", text_pos (text));
 776           break;
 777         }
 778
 779       if (type == MRSET_MD)
 780         {
 781           counted = text_parse_counted_string (text);
 782           if (counted == NULL)
 783             break;
 784         }
 785
 786       label = text_parse_counted_string (text);
 787       if (label == NULL)
 788         break;
 789
 790       variables = text_tokenize (text, '\n');
 791       if (variables == NULL)
 792         {
 793           sys_warn (r, "missing variable names following label "
 794                     "at offset %zu in mrsets record", text_pos (text));
 795           break;
 796         }
 797
 798       printf ("\t\"%s\": multiple %s set",
 799               name, type == MRSET_MC ? "category" : "dichotomy");
 800       if (counted != NULL)
 801         printf (", counted value \"%s\"", counted);
 802       if (cat_label_from_counted_values)
 803         printf (", category labels from counted values");
 804       if (label[0] != '\0')
 805         printf (", label \"%s\"", label);
 806       if (label_from_var_label)
 807         printf (", label from variable label");
 808       printf(", variables \"%s\"\n", variables);
 809     }
 810   close_text_record (text);
 811 }
 812
 813 /* Read record type 7, subtype 11. */
 814 static void
 815 read_display_parameters (struct sfm_reader *r, size_t size, size_t count)
 816 {
 817   size_t n_vars;
 818   bool includes_width;
 819   size_t i;
 820
 821   printf ("%08llx: variable display parameters\n",
 822           (long long int) ftello (r->file));
 823   if (size != 4)
 824     {
 825       sys_warn (r, "Bad size %zu on extension 11.", size);
 826       skip_bytes (r, size * count);
 827       return;
 828     }
 829
 830   n_vars = r->n_variables;
 831   if (count == 3 * n_vars)
 832     includes_width = true;
 833   else if (count == 2 * n_vars)
 834     includes_width = false;
 835   else
 836     {
 837       sys_warn (r, "Extension 11 has bad count %zu (for %zu variables.",
 838                 count, n_vars);
 839       skip_bytes (r, size * count);
 840       return;
 841     }
 842
 843   for (i = 0; i < n_vars; ++i)
 844     {
 845       int measure = read_int (r);
 846       int width = includes_width ? read_int (r) : 0;
 847       int align = read_int (r);
 848
 849       printf ("\tVar #%zu: measure=%d (%s)", i, measure,
 850               (measure == 1 ? "nominal"
 851                : measure == 2 ? "ordinal"
 852                : measure == 3 ? "scale"
 853                : "invalid"));
 854       if (includes_width)
 855         printf (", width=%d", width);
 856       printf (", align=%d (%s)\n", align,
 857               (align == 0 ? "left"
 858                : align == 1 ? "right"
 859                : align == 2 ? "centre"
 860                : "invalid"));
 861     }
 862 }
 863
 864 /* Reads record type 7, subtype 13, which gives the long name
 865    that corresponds to each short name.  */
 866 static void
 867 read_long_var_name_map (struct sfm_reader *r, size_t size, size_t count)
 868 {
 869   struct text_record *text;
 870   char *var;
 871   char *long_name;
 872
 873   printf ("%08llx: long variable names (short => long)\n",
 874           (long long int) ftello (r->file));
 875   text = open_text_record (r, size * count);
 876   while (read_variable_to_value_pair (text, &var, &long_name))
 877     printf ("\t%s => %s\n", var, long_name);
 878   close_text_record (text);
 879 }
 880
 881 /* Reads record type 7, subtype 14, which gives the real length
 882    of each very long string.  Rearranges DICT accordingly. */
 883 static void
 884 read_long_string_map (struct sfm_reader *r, size_t size, size_t count)
 885 {
 886   struct text_record *text;
 887   char *var;
 888   char *length_s;
 889
 890   printf ("%08llx: very long strings (variable => length)\n",
 891           (long long int) ftello (r->file));
 892   text = open_text_record (r, size * count);
 893   while (read_variable_to_value_pair (text, &var, &length_s))
 894     printf ("\t%s => %d\n", var, atoi (length_s));
 895   close_text_record (text);
 896 }
 897
 898 static bool
 899 read_attributes (struct sfm_reader *r, struct text_record *text,
 900                  const char *variable)
 901 {
 902   const char *key;
 903   int index;
 904
 905   for (;;)
 906     {
 907       key = text_tokenize (text, '(');
 908       if (key == NULL)
 909         return true;
 910
 911       for (index = 1; ; index++)
 912         {
 913           /* Parse the value. */
 914           const char *value = text_tokenize (text, '\n');
 915           if (value == NULL)
 916             {
 917               sys_warn (r, "%s: Error parsing attribute value %s[%d]",
 918                         variable, key, index);
 919               return false;
 920             }
 921           if (strlen (value) < 2
 922               || value[0] != '\'' || value[strlen (value) - 1] != '\'')
 923             sys_warn (r, "%s: Attribute value %s[%d] is not quoted: %s",
 924                       variable, key, index, value);
 925           else
 926             printf ("\t%s: %s[%d] = \"%.*s\"\n",
 927                     variable, key, index, (int) strlen (value) - 2, value + 1);
 928
 929           /* Was this the last value for this attribute? */
 930           if (text_match (text, ')'))
 931             break;
 932         }
 933
 934       if (text_match (text, '/'))
 935         return true;
 936     }
 937 }
 938
 939 /* Read extended number of cases record. */
 940 static void
 941 read_ncases64 (struct sfm_reader *r, size_t size, size_t count)
 942 {
 943   int64_t unknown, ncases64;
 944
 945   if (size != 8)
 946     {
 947       sys_warn (r, "Bad size %zu for extended number of cases.", size);
 948       skip_bytes (r, size * count);
 949       return;
 950     }
 951   if (count != 2)
 952     {
 953       sys_warn (r, "Bad count %zu for extended number of cases.", size);
 954       skip_bytes (r, size * count);
 955       return;
 956     }
 957   unknown = read_int64 (r);
 958   ncases64 = read_int64 (r);
 959   printf ("%08llx: extended number of cases: "
 960           "unknown=%"PRId64", ncases64=%"PRId64"\n",
 961           (long long int) ftello (r->file), unknown, ncases64);
 962 }
 963
 964 static void
 965 read_datafile_attributes (struct sfm_reader *r, size_t size, size_t count)
 966 {
 967   struct text_record *text;
 968
 969   printf ("%08llx: datafile attributes\n", (long long int) ftello (r->file));
 970   text = open_text_record (r, size * count);
 971   read_attributes (r, text, "datafile");
 972   close_text_record (text);
 973 }
 974
 975 static void
 976 read_character_encoding (struct sfm_reader *r, size_t size, size_t count)
 977 {
 978   long long int posn =  ftello (r->file);
 979   char *encoding = xcalloc (size, count + 1);
 980   read_string (r, encoding, count + 1);
 981
 982   printf ("%08llx: Character Encoding: %s\n", posn, encoding);
 983 }
 984
 985 static void
 986 read_long_string_value_labels (struct sfm_reader *r, size_t size, size_t count)
 987 {
 988   long long int start = ftello (r->file);
 989
 990   printf ("%08llx: long string value labels\n", start);
 991   while (ftello (r->file) - start < size * count)
 992     {
 993       long long posn = ftello (r->file);
 994       char var_name[ID_MAX_LEN + 1];
 995       int var_name_len;
 996       int n_values;
 997       int width;
 998       int i;
 999
1000       /* Read variable name. */
1001       var_name_len = read_int (r);
1002       if (var_name_len > ID_MAX_LEN)
1003         sys_error (r, "Variable name length in long string value label "
1004                    "record (%d) exceeds %d-byte limit.",
1005                    var_name_len, ID_MAX_LEN);
1006       read_string (r, var_name, var_name_len + 1);
1007
1008       /* Read width, number of values. */
1009       width = read_int (r);
1010       n_values = read_int (r);
1011
1012       printf ("\t%08llx: %s, width %d, %d values\n",
1013               posn, var_name, width, n_values);
1014
1015       /* Read values. */
1016       for (i = 0; i < n_values; i++)
1017         {
1018           char *value;
1019           int value_length;
1020
1021           char *label;
1022           int label_length;
1023
1024           posn = ftello (r->file);
1025
1026           /* Read value. */
1027           value_length = read_int (r);
1028           value = xmalloc (value_length + 1);
1029           read_string (r, value, value_length + 1);
1030
1031           /* Read label. */
1032           label_length = read_int (r);
1033           label = xmalloc (label_length + 1);
1034           read_string (r, label, label_length + 1);
1035
1036           printf ("\t\t%08llx: \"%s\" (%d bytes) => \"%s\" (%d bytes)\n",
1037                   posn, value, value_length, label, label_length);
1038
1039           free (value);
1040           free (label);
1041         }
1042     }
1043 }
1044
1045 static void
1046 read_long_string_missing_values (struct sfm_reader *r,
1047                                  size_t size, size_t count)
1048 {
1049   long long int start = ftello (r->file);
1050
1051   printf ("%08llx: long string missing values\n", start);
1052   while (ftello (r->file) - start < size * count)
1053     {
1054       long long posn = ftello (r->file);
1055       char var_name[ID_MAX_LEN + 1];
1056       uint8_t n_missing_values;
1057       int var_name_len;
1058       int i;
1059
1060       /* Read variable name. */
1061       var_name_len = read_int (r);
1062       if (var_name_len > ID_MAX_LEN)
1063         sys_error (r, "Variable name length in long string value label "
1064                    "record (%d) exceeds %d-byte limit.",
1065                    var_name_len, ID_MAX_LEN);
1066       read_string (r, var_name, var_name_len + 1);
1067
1068       /* Read number of values. */
1069       read_bytes (r, &n_missing_values, 1);
1070
1071       printf ("\t%08llx: %s, %d missing values:",
1072               posn, var_name, n_missing_values);
1073
1074       /* Read values. */
1075       for (i = 0; i < n_missing_values; i++)
1076         {
1077           char *value;
1078           int value_length;
1079
1080           posn = ftello (r->file);
1081
1082           /* Read value. */
1083           value_length = read_int (r);
1084           value = xmalloc (value_length + 1);
1085           read_string (r, value, value_length + 1);
1086
1087           printf (" \"%s\"", value);
1088
1089           free (value);
1090         }
1091       printf ("\n");
1092     }
1093 }
1094
1095 static void
1096 hex_dump (size_t offset, const void *buffer_, size_t buffer_size)
1097 {
1098   const uint8_t *buffer = buffer_;
1099
1100   while (buffer_size > 0)
1101     {
1102       size_t n = MIN (buffer_size, 16);
1103       size_t i;
1104
1105       printf ("%04zx", offset);
1106       for (i = 0; i < 16; i++)
1107         {
1108           if (i < n)
1109             printf ("%c%02x", i == 8 ? '-' : ' ', buffer[i]);
1110           else
1111             printf ("   ");
1112         }
1113
1114       printf (" |");
1115       for (i = 0; i < 16; i++)
1116         {
1117           unsigned char c = i < n ? buffer[i] : ' ';
1118           putchar (isprint (c) ? c : '.');
1119         }
1120       printf ("|\n");
1121
1122       offset += n;
1123       buffer += n;
1124       buffer_size -= n;
1125     }
1126 }
1127
1128 /* Reads and prints any type 7 record that we don't understand. */
1129 static void
1130 read_unknown_extension (struct sfm_reader *r, size_t size, size_t count)
1131 {
1132   unsigned char *buffer;
1133   size_t i;
1134
1135   if (size == 0 || count > 65536 / size)
1136     skip_bytes (r, size * count);
1137   else if (size != 1)
1138     {
1139       buffer = xmalloc (size);
1140       for (i = 0; i < count; i++)
1141         {
1142           read_bytes (r, buffer, size);
1143           hex_dump (i * size, buffer, size);
1144         }
1145       free (buffer);
1146     }
1147   else
1148     {
1149       buffer = xmalloc (count);
1150       read_bytes (r, buffer, count);
1151       print_string (CHAR_CAST (char *, buffer), count);
1152       free (buffer);
1153     }
1154 }
1155
1156 static void
1157 read_variable_attributes (struct sfm_reader *r, size_t size, size_t count)
1158 {
1159   struct text_record *text;
1160
1161   printf ("%08llx: variable attributes\n", (long long int) ftello (r->file));
1162   text = open_text_record (r, size * count);
1163   for (;;)
1164     {
1165       const char *variable = text_tokenize (text, ':');
1166       if (variable == NULL || !read_attributes (r, text, variable))
1167         break;
1168     }
1169   close_text_record (text);
1170 }
1171
1172 static void
1173 read_compressed_data (struct sfm_reader *r, int max_cases)
1174 {
1175   enum { N_OPCODES = 8 };
1176   uint8_t opcodes[N_OPCODES];
1177   long long int opcode_ofs;
1178   int opcode_idx;
1179   int case_num;
1180   int i;
1181
1182   read_int (r);
1183   printf ("\n%08llx: compressed data:\n", (long long int) ftello (r->file));
1184
1185   opcode_idx = N_OPCODES;
1186   opcode_ofs = 0;
1187   case_num = 0;
1188   for (case_num = 0; case_num < max_cases; case_num++)
1189     {
1190       printf ("%08llx: case %d's uncompressible data begins\n",
1191               (long long int) ftello (r->file), case_num);
1192       for (i = 0; i < r->n_var_widths; )
1193         {
1194           int width = r->var_widths[i];
1195           char raw_value[8];
1196           int opcode;
1197
1198           if (opcode_idx >= N_OPCODES)
1199             {
1200               opcode_ofs = ftello (r->file);
1201               if (i == 0)
1202                 {
1203                   if (!try_read_bytes (r, opcodes, 8))
1204                     return;
1205                 }
1206               else
1207                 read_bytes (r, opcodes, 8);
1208               opcode_idx = 0;
1209             }
1210           opcode = opcodes[opcode_idx];
1211           printf ("%08llx: variable %d: opcode %d: ",
1212                   opcode_ofs + opcode_idx, i, opcode);
1213
1214           switch (opcode)
1215             {
1216             default:
1217               printf ("%g", opcode - r->bias);
1218               if (width != 0)
1219                 printf (", but this is a string variable (width=%d)", width);
1220               printf ("\n");
1221               i++;
1222               break;
1223
1224             case 0:
1225               printf ("ignored padding\n");
1226               break;
1227
1228             case 252:
1229               printf ("end of data\n");
1230               return;
1231
1232             case 253:
1233               read_bytes (r, raw_value, 8);
1234               printf ("uncompressible data: ");
1235               print_untyped_value (r, raw_value);
1236               printf ("\n");
1237               i++;
1238               break;
1239
1240             case 254:
1241               printf ("spaces");
1242               if (width == 0)
1243                 printf (", but this is a numeric variable");
1244               printf ("\n");
1245               i++;
1246               break;
1247
1248             case 255:
1249               printf ("SYSMIS");
1250               if (width != 0)
1251                 printf (", but this is a string variable (width=%d)", width);
1252               printf ("\n");
1253               i++;
1254               break;
1255             }
1256
1257           opcode_idx++;
1258         }
1259     }
1260 }
1261 \f
1262 /* Helpers for reading records that consist of structured text
1263    strings. */
1264
1265 /* State. */
1266 struct text_record
1267   {
1268     struct sfm_reader *reader;  /* Reader. */
1269     char *buffer;               /* Record contents. */
1270     size_t size;                /* Size of buffer. */
1271     size_t pos;                 /* Current position in buffer. */
1272   };
1273
1274 /* Reads SIZE bytes into a text record for R,
1275    and returns the new text record. */
1276 static struct text_record *
1277 open_text_record (struct sfm_reader *r, size_t size)
1278 {
1279   struct text_record *text = xmalloc (sizeof *text);
1280   char *buffer = xmalloc (size + 1);
1281   read_bytes (r, buffer, size);
1282   buffer[size] = '\0';
1283   text->reader = r;
1284   text->buffer = buffer;
1285   text->size = size;
1286   text->pos = 0;
1287   return text;
1288 }
1289
1290 /* Closes TEXT and frees its storage.
1291    Not really needed, because the pool will free the text record anyway,
1292    but can be used to free it earlier. */
1293 static void
1294 close_text_record (struct text_record *text)
1295 {
1296   free (text->buffer);
1297   free (text);
1298 }
1299
1300 static char *
1301 text_tokenize (struct text_record *text, int delimiter)
1302 {
1303   size_t start = text->pos;
1304   while (text->pos < text->size
1305          && text->buffer[text->pos] != delimiter
1306          && text->buffer[text->pos] != '\0')
1307     text->pos++;
1308   if (start == text->pos)
1309     return NULL;
1310   text->buffer[text->pos++] = '\0';
1311   return &text->buffer[start];
1312 }
1313
1314 static bool
1315 text_match (struct text_record *text, int c)
1316 {
1317   if (text->pos < text->size && text->buffer[text->pos] == c)
1318     {
1319       text->pos++;
1320       return true;
1321     }
1322   else
1323     return false;
1324 }
1325
1326 /* Reads a integer value expressed in decimal, then a space, then a string that
1327    consists of exactly as many bytes as specified by the integer, then a space,
1328    from TEXT.  Returns the string, null-terminated, as a subset of TEXT's
1329    buffer (so the caller should not free the string). */
1330 static const char *
1331 text_parse_counted_string (struct text_record *text)
1332 {
1333   size_t start;
1334   size_t n;
1335   char *s;
1336
1337   start = text->pos;
1338   n = 0;
1339   while (isdigit ((unsigned char) text->buffer[text->pos]))
1340     n = (n * 10) + (text->buffer[text->pos++] - '0');
1341   if (start == text->pos)
1342     {
1343       sys_error (text->reader, "expecting digit at offset %zu in record",
1344                  text->pos);
1345       return NULL;
1346     }
1347
1348   if (!text_match (text, ' '))
1349     {
1350       sys_error (text->reader, "expecting space at offset %zu in record",
1351                  text->pos);
1352       return NULL;
1353     }
1354
1355   if (text->pos + n > text->size)
1356     {
1357       sys_error (text->reader, "%zu-byte string starting at offset %zu "
1358                  "exceeds record length %zu", n, text->pos, text->size);
1359       return NULL;
1360     }
1361
1362   s = &text->buffer[text->pos];
1363   if (s[n] != ' ')
1364     {
1365       sys_error (text->reader, "expecting space at offset %zu following "
1366                  "%zu-byte string", text->pos + n, n);
1367       return NULL;
1368     }
1369   s[n] = '\0';
1370   text->pos += n + 1;
1371   return s;
1372 }
1373
1374 /* Reads a variable=value pair from TEXT.
1375    Looks up the variable in DICT and stores it into *VAR.
1376    Stores a null-terminated value into *VALUE. */
1377 static bool
1378 read_variable_to_value_pair (struct text_record *text,
1379                              char **key, char **value)
1380 {
1381   *key = text_tokenize (text, '=');
1382   *value = text_tokenize (text, '\t');
1383   if (!*key || !*value)
1384     return false;
1385
1386   while (text->pos < text->size
1387          && (text->buffer[text->pos] == '\t'
1388              || text->buffer[text->pos] == '\0'))
1389     text->pos++;
1390   return true;
1391 }
1392
1393 /* Returns the current byte offset inside the TEXT's string. */
1394 static size_t
1395 text_pos (const struct text_record *text)
1396 {
1397   return text->pos;
1398 }
1399
1400 static const char *
1401 text_get_all (const struct text_record *text)
1402 {
1403   return text->buffer;
1404 }
1405 \f
1406 static void
1407 usage (void)
1408 {
1409   printf ("\
1410 %s, a utility for dissecting system files.\n\
1411 Usage: %s [OPTION]... SYSFILE...\n\
1412 where each SYSFILE is the name of a system file.\n\
1413 \n\
1414 Options:\n\
1415   --data[=MAXCASES]   print (up to MAXCASES cases of) compressed data\n\
1416   --help              display this help and exit\n\
1417   --version           output version information and exit\n",
1418           program_name, program_name);
1419 }
1420
1421 /* Displays a corruption message. */
1422 static void
1423 sys_msg (struct sfm_reader *r, const char *format, va_list args)
1424 {
1425   printf ("\"%s\" near offset 0x%llx: ",
1426           r->file_name, (long long int) ftello (r->file));
1427   vprintf (format, args);
1428   putchar ('\n');
1429 }
1430
1431 /* Displays a warning for the current file position. */
1432 static void
1433 sys_warn (struct sfm_reader *r, const char *format, ...)
1434 {
1435   va_list args;
1436
1437   va_start (args, format);
1438   sys_msg (r, format, args);
1439   va_end (args);
1440 }
1441
1442 /* Displays an error for the current file position,
1443    marks it as in an error state,
1444    and aborts reading it using longjmp. */
1445 static void
1446 sys_error (struct sfm_reader *r, const char *format, ...)
1447 {
1448   va_list args;
1449
1450   va_start (args, format);
1451   sys_msg (r, format, args);
1452   va_end (args);
1453
1454   exit (EXIT_FAILURE);
1455 }
1456 \f
1457 /* Reads BYTE_CNT bytes into BUF.
1458    Returns true if exactly BYTE_CNT bytes are successfully read.
1459    Aborts if an I/O error or a partial read occurs.
1460    If EOF_IS_OK, then an immediate end-of-file causes false to be
1461    returned; otherwise, immediate end-of-file causes an abort
1462    too. */
1463 static inline bool
1464 read_bytes_internal (struct sfm_reader *r, bool eof_is_ok,
1465                      void *buf, size_t byte_cnt)
1466 {
1467   size_t bytes_read = fread (buf, 1, byte_cnt, r->file);
1468   if (bytes_read == byte_cnt)
1469     return true;
1470   else if (ferror (r->file))
1471     sys_error (r, "System error: %s.", strerror (errno));
1472   else if (!eof_is_ok || bytes_read != 0)
1473     sys_error (r, "Unexpected end of file.");
1474   else
1475     return false;
1476 }
1477
1478 /* Reads BYTE_CNT into BUF.
1479    Aborts upon I/O error or if end-of-file is encountered. */
1480 static void
1481 read_bytes (struct sfm_reader *r, void *buf, size_t byte_cnt)
1482 {
1483   read_bytes_internal (r, false, buf, byte_cnt);
1484 }
1485
1486 /* Reads BYTE_CNT bytes into BUF.
1487    Returns true if exactly BYTE_CNT bytes are successfully read.
1488    Returns false if an immediate end-of-file is encountered.
1489    Aborts if an I/O error or a partial read occurs. */
1490 static bool
1491 try_read_bytes (struct sfm_reader *r, void *buf, size_t byte_cnt)
1492 {
1493   return read_bytes_internal (r, true, buf, byte_cnt);
1494 }
1495
1496 /* Reads a 32-bit signed integer from R and returns its value in
1497    host format. */
1498 static int
1499 read_int (struct sfm_reader *r)
1500 {
1501   uint8_t integer[4];
1502   read_bytes (r, integer, sizeof integer);
1503   return integer_get (r->integer_format, integer, sizeof integer);
1504 }
1505
1506 /* Reads a 64-bit signed integer from R and returns its value in
1507    host format. */
1508 static int64_t
1509 read_int64 (struct sfm_reader *r)
1510 {
1511   uint8_t integer[8];
1512   read_bytes (r, integer, sizeof integer);
1513   return integer_get (r->integer_format, integer, sizeof integer);
1514 }
1515
1516 /* Reads a 64-bit floating-point number from R and returns its
1517    value in host format. */
1518 static double
1519 read_float (struct sfm_reader *r)
1520 {
1521   uint8_t number[8];
1522   read_bytes (r, number, sizeof number);
1523   return float_get_double (r->float_format, number);
1524 }
1525
1526 /* Reads exactly SIZE - 1 bytes into BUFFER
1527    and stores a null byte into BUFFER[SIZE - 1]. */
1528 static void
1529 read_string (struct sfm_reader *r, char *buffer, size_t size)
1530 {
1531   assert (size > 0);
1532   read_bytes (r, buffer, size - 1);
1533   buffer[size - 1] = '\0';
1534 }
1535
1536 /* Skips BYTES bytes forward in R. */
1537 static void
1538 skip_bytes (struct sfm_reader *r, size_t bytes)
1539 {
1540   while (bytes > 0)
1541     {
1542       char buffer[1024];
1543       size_t chunk = MIN (sizeof buffer, bytes);
1544       read_bytes (r, buffer, chunk);
1545       bytes -= chunk;
1546     }
1547 }
1548
1549 static void
1550 trim_spaces (char *s)
1551 {
1552   char *end = strchr (s, '\0');
1553   while (end > s && end[-1] == ' ')
1554     end--;
1555   *end = '\0';
1556 }
1557
1558 static void
1559 print_string (const char *s, size_t len)
1560 {
1561   if (memchr (s, 0, len) == 0)
1562     {
1563       size_t i;
1564
1565       for (i = 0; i < len; i++)
1566         {
1567           unsigned char c = s[i];
1568
1569           if (c == '\\')
1570             printf ("\\\\");
1571           else if (c == '\n' || isprint (c))
1572             putchar (c);
1573           else
1574             printf ("\\%02x", c);
1575         }
1576       putchar ('\n');
1577     }
1578   else
1579     hex_dump (0, s, len);
1580 }