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