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

   1 #include <stdbool.h>
   2 #include <stdint.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <sys/stat.h>
   7 #include <unistd.h>
   8
   9 static uint8_t *data;
  10 static size_t n;
  11
  12 static bool
  13 all_ascii(const uint8_t *p, size_t n)
  14 {
  15   for (size_t i = 0; i < n; i++)
  16     if (p[i] < 32 || p[i] > 126)
  17       return false;
  18   return true;
  19 }
  20
  21 static size_t
  22 try_find(const char *target, size_t target_len)
  23 {
  24   const uint8_t *pos = (const uint8_t *) memmem (data, n, target, target_len);
  25   return pos ? pos - data : 0;
  26 }
  27
  28 static size_t
  29 try_find_tail(const char *target, size_t target_len)
  30 {
  31   size_t pos = try_find(target, target_len);
  32   return pos ? pos + target_len : 0;
  33 }
  34
  35 static size_t
  36 find(const char *target, size_t target_len)
  37 {
  38   size_t pos = try_find(target, target_len);
  39   if (!pos)
  40     {
  41       fprintf (stderr, "not found\n");
  42       exit(1);
  43     }
  44   return pos;
  45 }
  46
  47 static size_t
  48 find_tail(const char *target, size_t target_len)
  49 {
  50   size_t pos = try_find_tail(target, target_len);
  51   if (!pos)
  52     {
  53       fprintf (stderr, "not found\n");
  54       exit(1);
  55     }
  56   return pos;
  57 }
  58
  59 size_t pos;
  60
  61 #define XSTR(x) #x
  62 #define STR(x) XSTR(x)
  63 #define WHERE __FILE__":" STR(__LINE__)
  64
  65 static unsigned int
  66 get_u32(void)
  67 {
  68   uint32_t x;
  69   memcpy(&x, &data[pos], 4);
  70   pos += 4;
  71   return x;
  72 }
  73
  74 static double
  75 get_double(void)
  76 {
  77   double x;
  78   memcpy(&x, &data[pos], 8);
  79   pos += 8;
  80   return x;
  81 }
  82
  83 static bool
  84 match_u32(uint32_t x)
  85 {
  86   if (get_u32() == x)
  87     return true;
  88   pos -= 4;
  89   return false;
  90 }
  91
  92 static void
  93 match_u32_assert(uint32_t x, const char *where)
  94 {
  95   unsigned int y = get_u32();
  96   if (x != y)
  97     {
  98       fprintf(stderr, "%s: 0x%x: expected i%u, got i%u\n", where, pos - 4, x, y);
  99       exit(1);
 100     }
 101 }
 102 #define match_u32_assert(x) match_u32_assert(x, WHERE)
 103
 104 static bool
 105 match_byte(uint8_t b)
 106 {
 107   if (pos < n && data[pos] == b)
 108     {
 109       pos++;
 110       return true;
 111     }
 112   else
 113     return false;
 114 }
 115
 116 static void
 117 match_byte_assert(uint8_t b, const char *where)
 118 {
 119   if (!match_byte(b))
 120     {
 121       fprintf(stderr, "%s: 0x%x: expected %02x, got %02x\n", where, pos, b, data[pos]);
 122       exit(1);
 123     }
 124 }
 125 #define match_byte_assert(b) match_byte_assert(b, WHERE)
 126
 127 static char *
 128 get_string(const char *where)
 129 {
 130   if (1
 131       /*data[pos + 1] == 0 && data[pos + 2] == 0 && data[pos + 3] == 0*/
 132       /*&& all_ascii(&data[pos + 4], data[pos])*/)
 133     {
 134       int len = data[pos] + data[pos + 1] * 256;
 135       char *s = malloc(len + 1);
 136
 137       memcpy(s, &data[pos + 4], len);
 138       s[len] = 0;
 139       pos += 4 + len;
 140       return s;
 141     }
 142   else
 143     {
 144       fprintf(stderr, "%s: 0x%x: expected string\n", where, pos);
 145       exit(1);
 146     }
 147 }
 148 #define get_string() get_string(WHERE)
 149
 150 static void
 151 dump_value(int level)
 152 {
 153   for (int i = 0; i <= level; i++)
 154     printf ("    ");
 155
 156   match_byte (0);
 157   match_byte (0);
 158   match_byte (0);
 159   match_byte (0);
 160   if (match_byte (3))
 161     {
 162       char *s1 = get_string();
 163       if (match_byte (0x31))
 164         {
 165           if (match_u32 (1))
 166             {
 167               printf("(footnote %d) ", get_u32());
 168               match_byte_assert (0);
 169               match_byte_assert (0);
 170               int subn = get_u32 ();
 171               printf ("nested %d bytes", subn);
 172               pos += subn;
 173             }
 174           else if (match_u32 (2))
 175             {
 176               printf("(special 2)");
 177               match_byte_assert(0);
 178               match_byte_assert(0);
 179               match_u32_assert(1);
 180               match_byte_assert(0);
 181               match_byte_assert(0);
 182               int subn = get_u32 ();
 183               printf ("nested %d bytes", subn);
 184               pos += subn;
 185             }
 186           else
 187             {
 188               match_u32_assert(3);
 189               printf("(special 3)");
 190               match_byte_assert(0);
 191               match_byte_assert(0);
 192               match_byte_assert(1);
 193               match_byte_assert(0);
 194               int subn = get_u32 ();
 195               printf ("nested %d bytes, ", subn);
 196               pos += subn;
 197               subn = get_u32 ();
 198               printf ("nested %d bytes, ", subn);
 199               pos += subn;
 200             }
 201         }
 202       else
 203         match_byte_assert (0x58);
 204       char *s2 = get_string();
 205       char *s3 = get_string();
 206       if (strcmp(s1, s3))
 207         printf("strings \"%s\", \"%s\" and \"%s\"", s1, s2, s3);
 208       else
 209         printf("string \"%s\" and \"%s\"", s1, s2);
 210       match_byte (0);
 211       match_byte (0);
 212       match_byte (0);
 213       match_byte (1);
 214       match_byte (1);
 215       match_byte (0);
 216       match_byte (0);
 217       match_byte (0);
 218       match_byte (1);
 219     }
 220   else if (match_byte (5))
 221     {
 222       match_byte_assert (0x58);
 223       printf ("variable \"%s\"", get_string());
 224       get_string();
 225       if (!match_byte(1) && !match_byte(2))
 226         match_byte_assert(3);
 227       match_byte (0);
 228       match_byte (0);
 229       match_byte (0);
 230       match_byte (0);
 231     }
 232   else if (match_byte (2))
 233     {
 234       unsigned int format;
 235       char *var, *vallab;
 236       double value;
 237
 238       match_byte_assert (0x58);
 239       format = get_u32 ();
 240       value = get_double ();
 241       var = get_string ();
 242       vallab = get_string ();
 243       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
 244               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
 245       if (!match_byte (1) && !match_byte(2))
 246         match_byte_assert (3);
 247       match_byte (0);
 248       match_byte (0);
 249       match_byte (0);
 250       match_byte (0);
 251       match_byte (0);
 252       match_byte (0);
 253       match_byte (0);
 254     }
 255   else if (match_byte (4))
 256     {
 257       unsigned int format;
 258       char *var, *vallab, *value;
 259
 260       match_byte_assert (0x58);
 261       format = get_u32 ();
 262       vallab = get_string ();
 263       var = get_string ();
 264       if (!match_byte(1) && !match_byte(2))
 265         match_byte_assert (3);
 266       value = get_string ();
 267       printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
 268               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
 269       match_byte (0);
 270       match_byte (0);
 271       match_byte (0);
 272       match_byte (0);
 273     }
 274   else if (match_byte (1))
 275     {
 276       unsigned int format;
 277       double value;
 278
 279       if (match_byte (0x31))
 280         {
 281           if (match_u32 (1))
 282             {
 283               printf("(footnote %d) ", get_u32());
 284               match_byte_assert (0);
 285               match_byte_assert (0);
 286               int subn = get_u32 ();
 287               printf ("nested %d bytes", subn);
 288               pos += subn;
 289             }
 290         }
 291       else
 292         match_byte_assert (0x58);
 293       format = get_u32 ();
 294       value = get_double ();
 295       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
 296       match_byte (1);
 297       match_byte (0);
 298       match_byte (0);
 299       match_byte (0);
 300       match_byte (1);
 301     }
 302   else if (match_byte (0x31))
 303     {
 304       if (match_u32 (1))
 305         {
 306           printf("(footnote %d) ", get_u32());
 307           match_byte_assert (0);
 308           match_byte_assert (0);
 309           int subn = get_u32 ();
 310           printf ("nested %d bytes", subn);
 311           pos += subn;
 312         }
 313       else
 314         {
 315           match_u32_assert (0);
 316           match_u32_assert (0);
 317           int subn = get_u32 ();
 318           printf ("nested %d bytes", subn);
 319           pos += subn;
 320         }
 321       char *base = get_string();
 322       int x = get_u32();
 323       printf ("\"%s\"; %d variables:\n", base, x);
 324       if (match_u32(0))
 325         {
 326           for (int i = 0; i < x; i++)
 327             {
 328               dump_value (level+1);
 329               putchar('\n');
 330             }
 331         }
 332       else
 333         {
 334           for (int i = 0; i < x; i++)
 335             {
 336               int y = get_u32();
 337               match_u32_assert(0);
 338               for (int j = 0; j <= level; j++)
 339                 printf ("    ");
 340               printf("variable %d has %d values:\n", i, y);
 341               for (int j = 0; j < y; j++)
 342                 {
 343                   if (match_byte(3))
 344                     {
 345                       char *a = get_string();
 346                       match_byte_assert(0x58);
 347                       char *b = get_string();
 348                       char *c = get_string();
 349                       for (int k = 0; k <= level + 1; k++)
 350                         printf ("    ");
 351                       printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
 352                       match_byte(0);
 353                       match_byte(0);
 354                       match_byte(0);
 355                       match_byte(0);
 356                       match_byte(0);
 357                     }
 358                   else
 359                     dump_value (level+1);
 360                   putchar('\n');
 361                 }
 362             }
 363         }
 364     }
 365   else
 366     {
 367
 368       match_byte_assert (0x58);
 369       char *base = get_string();
 370       int x = get_u32();
 371       printf ("\"%s\" with %d variables:\n", base, x);
 372       if (match_u32(0))
 373         {
 374           for (int i = 0; i < x; i++)
 375             {
 376               dump_value (level+1);
 377               putchar('\n');
 378             }
 379         }
 380       else
 381         {
 382           for (int i = 0; i < x; i++)
 383             {
 384               int y = get_u32();
 385               match_u32_assert(0);
 386               for (int j = 0; j <= level; j++)
 387                 printf ("    ");
 388               printf("variable %d has %d values:\n", i, y);
 389               for (int j = 0; j < y; j++)
 390                 {
 391                   if (match_byte(3))
 392                     {
 393                       char *a = get_string();
 394                       match_byte_assert(0x58);
 395                       char *b = get_string();
 396                       char *c = get_string();
 397                       for (int k = 0; k <= level + 1; k++)
 398                         printf ("    ");
 399                       printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
 400                       match_byte(0);
 401                       match_byte(0);
 402                       match_byte(0);
 403                       match_byte(0);
 404                       match_byte(0);
 405                     }
 406                   else
 407                     dump_value (level+1);
 408                   putchar('\n');
 409                 }
 410             }
 411         }
 412     }
 413 }
 414
 415 static void
 416 dump_dim_value(int level)
 417 {
 418   for (int i = 0; i <= level; i++)
 419     printf ("    ");
 420
 421   if (match_byte (3))
 422     {
 423       get_string();
 424       if (match_byte (0x31))
 425         {
 426           match_u32 (1);
 427           printf("(footnote %d) ", get_u32());
 428           match_byte_assert (0);
 429           match_byte_assert (0);
 430           int subn = get_u32 ();
 431           printf ("nested %d bytes", subn);
 432           pos += subn;
 433         }
 434       else
 435         match_byte_assert (0x58);
 436       get_string();
 437       printf("string \"%s\"", get_string());
 438       match_byte (0);
 439       match_byte_assert (1);
 440       match_byte (0);
 441       match_byte (0);
 442       match_byte (0);
 443       match_byte (1);
 444     }
 445   else if (match_byte (5))
 446     {
 447       match_byte_assert (0x58);
 448       printf ("variable \"%s\"", get_string());
 449       get_string();
 450       match_byte_assert (2);
 451     }
 452   else if (match_byte (2))
 453     {
 454       unsigned int format;
 455       char *var, *vallab;
 456       double value;
 457
 458       match_byte_assert (0x58);
 459       format = get_u32 ();
 460       value = get_double ();
 461       var = get_string ();
 462       vallab = get_string ();
 463       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
 464               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
 465       if (!match_u32 (3))
 466         match_u32_assert (2);
 467       match_byte (0);
 468     }
 469   else if (match_byte (1))
 470     {
 471       unsigned int format;
 472       double value;
 473
 474       match_byte_assert (0x58);
 475       format = get_u32 ();
 476       value = get_double ();
 477       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
 478       match_byte (1);
 479       match_byte (0);
 480       match_byte (0);
 481       match_byte (0);
 482       match_byte (1);
 483     }
 484   else
 485     {
 486       int subn;
 487
 488       match_byte (0);
 489       match_byte_assert (0x31);
 490       match_u32_assert (0);
 491       match_u32_assert (0);
 492       subn = get_u32 ();
 493       printf ("nested %d bytes", subn);
 494       pos += subn;
 495       printf ("; \"%s\", substitutions:", get_string());
 496       int total_subs = get_u32();
 497       int x = get_u32();
 498       if (x)
 499         {
 500           total_subs = (total_subs - 1) + x;
 501           match_u32_assert (0);
 502         }
 503       printf (" (total %d)", total_subs);
 504
 505       for (int i = 0; i < total_subs; i++)
 506         {
 507           putc ('\n', stdout);
 508           dump_value (level + 1);
 509         }
 510     }
 511 }
 512
 513 static void
 514 dump_category(int level)
 515 {
 516   match_byte (0);
 517   match_byte (0);
 518   match_byte (0);
 519   match_byte (0);
 520   dump_value (level);
 521
 522   if (match_u32 (2))
 523     get_u32 ();
 524   else if (match_u32 (1))
 525     {
 526       match_byte (0);
 527       match_byte (0);
 528       match_byte (0);
 529       get_u32 ();
 530     }
 531   else if (match_byte (1))
 532     {
 533       match_byte (0);
 534       if (!match_u32 (2))
 535         match_u32_assert (1);
 536       match_byte (0);
 537       get_u32();
 538     }
 539   else
 540     {
 541       match_u32_assert (0);
 542       get_u32 ();
 543     }
 544
 545   int n_categories = get_u32();
 546   if (n_categories > 0)
 547     printf (", %d subcategories:", n_categories);
 548   printf("\n");
 549   for (int i = 0; i < n_categories; i++)
 550     dump_category (level + 1);
 551 }
 552
 553 static void
 554 dump_dim(void)
 555 {
 556   int n_categories;
 557   printf("next dim\n");
 558   match_byte(0);
 559   if (match_byte(3))
 560     {
 561       get_string();
 562       match_byte_assert(0x58);
 563       get_string();
 564       printf("string \"%s\": ", get_string());
 565       match_byte(1) || match_byte(0);
 566     }
 567   else if (match_byte(5))
 568     {
 569       match_byte_assert(0x58);
 570       printf("variable \"%s\": ", get_string());
 571       get_string();
 572       if (!match_byte(2))
 573         match_byte_assert(3);
 574     }
 575   else if (match_byte(0x31))
 576     {
 577       int subn;
 578       int total_subs = 1;
 579
 580       match_u32_assert (0);
 581       match_u32_assert (0);
 582       subn = get_u32 ();
 583       printf ("nested %d bytes", subn);
 584       pos += subn;
 585       printf ("; \"%s\", substitutions:", get_string());
 586       for (;;)
 587         {
 588           int n_subst = get_u32();
 589           if (!n_subst)
 590             break;
 591           printf (" %d", n_subst);
 592           total_subs *= n_subst;
 593         }
 594
 595       for (int i = 0; i < total_subs; i++)
 596         {
 597           putc ('\n', stdout);
 598           dump_dim_value (0);
 599         }
 600     }
 601   else
 602     {
 603       int total_subs = 1;
 604
 605       match_byte_assert (0x58);
 606       printf ("\"%s\" with substitutions:", get_string());
 607       for (;;)
 608         {
 609           int n_subst = get_u32();
 610           if (!n_subst)
 611             break;
 612           printf (" %d", n_subst);
 613           total_subs *= n_subst;
 614         }
 615
 616       for (int i = 0; i < total_subs; i++)
 617         {
 618           putc ('\n', stdout);
 619           dump_dim_value (0);
 620         }
 621     }
 622
 623   /* This byte is usually 0x02 but 0x00 and 0x75 (!) have also been spotted. */
 624   pos++;
 625
 626   if (!match_byte(0) && !match_byte(1))
 627     match_byte_assert(2);
 628   if (!match_u32(0))
 629     match_u32_assert(2);
 630   if (!match_byte(0))
 631     match_byte_assert(1);
 632   match_byte(0);
 633   match_byte(0);
 634   match_byte(0);
 635   match_byte(0);
 636   get_u32();
 637   match_byte(0);
 638   match_byte(0);
 639   match_byte(0);
 640   match_byte(0);
 641   n_categories = get_u32();
 642   printf("%d nested categories\n", n_categories);
 643   for (int i = 0; i < n_categories; i++)
 644     dump_category (0);
 645 }
 646
 647 int n_dims;
 648 static void
 649 dump_dims(void)
 650 {
 651   n_dims = get_u32();
 652   printf ("%u dimensions\n", n_dims);
 653   for (int i = 0; i < n_dims; i++)
 654     {
 655       printf("\n");
 656       dump_dim ();
 657     }
 658 }
 659
 660 static void
 661 dump_data(void)
 662 {
 663 #if 1
 664   int a[16];
 665   for (int i = 0; i < 3 + n_dims; i++)
 666     a[i] = get_u32();
 667   printf ("data intro:");
 668   for (int i = 0; i < 3 + n_dims; i++)
 669     printf(" %d", a[i]);
 670   printf("\n");
 671 #else
 672   fprintf (stderr,"data intro (%d dims):", n_dims);
 673   for (int i = 0; i < 3+n_dims; i++)
 674     fprintf (stderr," %d", get_u32());
 675   fprintf(stderr,"\n");
 676 #endif
 677   int x = get_u32();
 678   printf ("%d data values, starting at %08x\n", x, pos);
 679   for (int i = 0; i < x; i++)
 680     {
 681       printf("%08x, index %d:\n", pos, get_u32());
 682       match_u32_assert(0);
 683       match_byte(0);
 684       match_byte(0);
 685       match_byte(0);
 686       match_byte(0);
 687       if (match_byte (1))
 688         {
 689           unsigned int format;
 690           double value;
 691
 692           if (match_byte (0x31))
 693             {
 694               if (match_u32 (0))
 695                 {
 696                   if (match_u32 (1))
 697                     get_string();
 698                   else
 699                     match_u32_assert (0);
 700                   int subn = get_u32 ();
 701                   printf ("nested %d bytes", subn);
 702                   pos += subn;
 703                 }
 704               else if (match_u32 (1))
 705                 {
 706                   printf("(footnote %d) ", get_u32());
 707                   match_byte_assert (0);
 708                   match_byte_assert (0);
 709                   int subn = get_u32 ();
 710                   printf ("nested %d bytes", subn);
 711                   pos += subn;
 712                 }
 713               else
 714                 {
 715                   match_u32_assert(2);
 716                   printf("(special 2)");
 717                   match_byte_assert(0);
 718                   match_byte_assert(0);
 719                   match_u32_assert(1);
 720                   match_byte_assert(0);
 721                   match_byte_assert(0);
 722                   int subn = get_u32 ();
 723                   printf ("nested %d bytes", subn);
 724                   pos += subn;
 725                 }
 726             }
 727           else
 728             match_byte_assert (0x58);
 729           format = get_u32 ();
 730           value = get_double ();
 731           printf ("    value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
 732         }
 733       else if (match_byte (3))
 734         {
 735           get_string();
 736           if (match_byte (0x31))
 737             {
 738               if (match_u32 (0))
 739                 {
 740                   match_u32_assert (1);
 741                   get_string ();
 742                   int subn = get_u32 ();
 743                   printf ("nested %d bytes", subn);
 744                   pos += subn;
 745                 }
 746               else if (match_u32 (1))
 747                 {
 748                   printf("(footnote %d) ", get_u32());
 749                   match_byte_assert (0);
 750                   match_byte_assert (0);
 751                   int subn = get_u32 ();
 752                   printf ("nested %d bytes", subn);
 753                   pos += subn;
 754                 }
 755               else if (match_u32 (2))
 756                 {
 757                   printf("(special 2)");
 758                   match_byte_assert(0);
 759                   match_byte_assert(0);
 760                   match_u32_assert(1);
 761                   match_byte_assert(0);
 762                   match_byte_assert(0);
 763                   int subn = get_u32 ();
 764                   printf ("nested %d bytes", subn);
 765                   pos += subn;
 766                 }
 767               else
 768                 {
 769                   match_u32_assert(3);
 770                   printf("(special 3)");
 771                   match_byte_assert(0);
 772                   match_byte_assert(0);
 773                   match_byte_assert(1);
 774                   match_byte_assert(0);
 775                   int subn = get_u32 ();
 776                   printf ("nested %d bytes, ", subn);
 777                   pos += subn;
 778                   subn = get_u32 ();
 779                   printf ("nested %d bytes, ", subn);
 780                   pos += subn;
 781                 }
 782             }
 783           else
 784             match_byte_assert (0x58);
 785           get_string();
 786           printf("string \"%s\"", get_string());
 787           match_byte (0);
 788         }
 789       else if (match_byte (2))
 790         {
 791           unsigned int format;
 792           char *var, *vallab;
 793           double value;
 794
 795           match_byte_assert (0x58);
 796           format = get_u32 ();
 797           value = get_double ();
 798           var = get_string ();
 799           vallab = get_string ();
 800           printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
 801                   value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
 802           if (!match_byte (1) && !match_byte(2))
 803             match_byte_assert (3);
 804         }
 805       else if (match_byte (4))
 806         {
 807           unsigned int format;
 808           char *var, *vallab, *value;
 809
 810           match_byte_assert (0x58);
 811           format = get_u32 ();
 812           vallab = get_string ();
 813           var = get_string ();
 814           if (!match_byte(1) && !match_byte(2))
 815             match_byte_assert (3);
 816           value = get_string ();
 817           printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
 818                   value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
 819         }
 820       else if (match_byte (5))
 821         {
 822           match_byte_assert (0x58);
 823           printf ("variable \"%s\"", get_string());
 824           get_string();
 825           if (!match_byte(1) && !match_byte(2))
 826             match_byte_assert(3);
 827           match_byte (0);
 828           match_byte (0);
 829           match_byte (0);
 830           match_byte (0);
 831         }
 832       else if (match_byte(0x31))
 833         {
 834           if (match_u32 (1))
 835             {
 836               printf("(footnote %d) ", get_u32());
 837               match_byte_assert (0);
 838               match_byte_assert (0);
 839               int subn = get_u32 ();
 840               printf ("nested %d bytes", subn);
 841               pos += subn;
 842             }
 843           else
 844             {
 845               match_u32_assert (0);
 846               match_u32_assert (0);
 847               int subn = get_u32 ();
 848               printf ("nested %d bytes", subn);
 849               pos += subn;
 850             }
 851           char *base = get_string();
 852           int x = get_u32();
 853           printf ("\"%s\"; %d variables:\n", base, x);
 854           for (int i = 0; i < x; i++)
 855             {
 856               int y = get_u32();
 857               if (!y)
 858                 y = 1;
 859               else
 860                 match_u32_assert(0);
 861               for (int j = 0; j <= 0; j++)
 862                 printf ("    ");
 863               printf("variable %d has %d values:\n", i, y);
 864               for (int j = 0; j < y; j++)
 865                 {
 866                   if (match_byte (1))
 867                     {
 868                       unsigned int format;
 869                       double value;
 870
 871                       if (match_byte (0x31))
 872                         {
 873                           if (match_u32 (0))
 874                             {
 875                               if (match_u32 (1))
 876                                 get_string();
 877                               else
 878                                 match_u32_assert (0);
 879                               int subn = get_u32 ();
 880                               printf ("nested %d bytes", subn);
 881                               pos += subn;
 882                             }
 883                           else if (match_u32 (1))
 884                             {
 885                               printf("(footnote %d) ", get_u32());
 886                               match_byte_assert (0);
 887                               match_byte_assert (0);
 888                               int subn = get_u32 ();
 889                               printf ("nested %d bytes", subn);
 890                               pos += subn;
 891                             }
 892                           else
 893                             {
 894                               match_u32_assert(2);
 895                               printf("(special 2)");
 896                               match_byte_assert(0);
 897                               match_byte_assert(0);
 898                               match_u32_assert(1);
 899                               match_byte_assert(0);
 900                               match_byte_assert(0);
 901                               int subn = get_u32 ();
 902                               printf ("nested %d bytes", subn);
 903                               pos += subn;
 904                             }
 905                         }
 906                       else
 907                         match_byte_assert (0x58);
 908                       format = get_u32 ();
 909                       value = get_double ();
 910                       printf ("    value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
 911                     }
 912                   else if (match_byte(3))
 913                     {
 914                       char *a = get_string();
 915                       match_byte_assert(0x58);
 916                       char *b = get_string();
 917                       char *c = get_string();
 918                       for (int k = 0; k <= 1; k++)
 919                         printf ("    ");
 920                       printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
 921                       match_byte(0);
 922                       match_byte(0);
 923                       match_byte(0);
 924                       match_byte(0);
 925                     }
 926                   else if (match_byte(5))
 927                     {
 928                       match_byte_assert (0x58);
 929                       printf ("variable \"%s\"", get_string());
 930                       get_string();
 931                       if (!match_byte(1) && !match_byte(2))
 932                         match_byte_assert(3);
 933                       match_byte (0);
 934                       match_byte (0);
 935                       match_byte (0);
 936                       match_byte (0);
 937                     }
 938                   else
 939                     dump_value (0);
 940                   putchar('\n');
 941                 }
 942             }
 943         }
 944       else
 945         {
 946           match_byte_assert (0x58);
 947           char *base = get_string();
 948           int x = get_u32();
 949           printf ("\"%s\" with %d variables:\n", base, x);
 950           for (int i = 0; i < x; i++)
 951             {
 952               int y = get_u32();
 953               if (!y)
 954                 y = 1;
 955               else
 956                 match_u32_assert(0);
 957               for (int j = 0; j <= 0; j++)
 958                 printf ("    ");
 959               printf("variable %d has %d values:\n", i, y);
 960               for (int j = 0; j < y; j++)
 961                 {
 962                   if (match_byte(3))
 963                     {
 964                       char *a = get_string();
 965                       match_byte_assert(0x58);
 966                       char *b = get_string();
 967                       char *c = get_string();
 968                       for (int k = 0; k <= 1; k++)
 969                         printf ("    ");
 970                       printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
 971                       match_byte(0);
 972                       match_byte(0);
 973                       match_byte(0);
 974                       match_byte(0);
 975                       match_byte(0);
 976                     }
 977                   else if (match_byte (1))
 978                     {
 979                       unsigned int format;
 980                       double value;
 981
 982                       if (match_byte (0x31))
 983                         {
 984                           if (match_u32 (1))
 985                             {
 986                               printf("(footnote %d) ", get_u32());
 987                               match_byte_assert (0);
 988                               match_byte_assert (0);
 989                               int subn = get_u32 ();
 990                               printf ("nested %d bytes", subn);
 991                               pos += subn;
 992                             }
 993                         }
 994                       else
 995                         match_byte_assert (0x58);
 996                       format = get_u32 ();
 997                       value = get_double ();
 998                       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
 999                     }
1000                   else
1001                     dump_value (1);
1002                   putchar('\n');
1003                 }
1004             }
1005         }
1006       putchar('\n');
1007     }
1008 }
1009
1010 static void
1011 dump_title_value_31(int level)
1012 {
1013   if (match_byte (0x31))
1014     {
1015       if (match_u32 (1))
1016         {
1017           printf("(footnote %d) ", get_u32());
1018           match_byte_assert (0);
1019           match_byte_assert (0);
1020           int subn = get_u32 ();
1021           printf ("nested %d bytes", subn);
1022           pos += subn;
1023         }
1024       else if (match_u32 (2))
1025         {
1026           printf("(special 2)");
1027           match_byte_assert(0);
1028           match_byte_assert(0);
1029           if (!match_u32(2))
1030             match_u32_assert(1);
1031           match_byte_assert(0);
1032           match_byte_assert(0);
1033           int subn = get_u32 ();
1034           printf ("nested %d bytes", subn);
1035           pos += subn;
1036         }
1037       else
1038         {
1039           match_u32_assert(3);
1040           printf("(special 3)");
1041           match_byte_assert(0);
1042           match_byte_assert(0);
1043           match_byte_assert(1);
1044           match_byte_assert(0);
1045           int subn = get_u32 ();
1046           printf ("nested %d bytes, ", subn);
1047           pos += subn;
1048           subn = get_u32 ();
1049           printf ("nested %d bytes, ", subn);
1050           pos += subn;
1051         }
1052     }
1053   else
1054     match_byte_assert (0x58);
1055 }
1056
1057 static void
1058 dump_title_value(int level)
1059 {
1060   for (int i = 0; i <= level; i++)
1061     printf ("    ");
1062
1063   match_byte (0);
1064   match_byte (0);
1065   match_byte (0);
1066   match_byte (0);
1067   match_byte (0);
1068   if (match_byte (3))
1069     {
1070       get_string();
1071       dump_title_value_31(level);
1072       get_string();
1073       printf("string \"%s\"", get_string());
1074       match_byte (0);
1075       match_byte (0);
1076       match_byte (0);
1077       match_byte (1);
1078       match_byte (1);
1079       match_byte (0);
1080       match_byte (0);
1081       match_byte (0);
1082       match_byte (1);
1083     }
1084   else if (match_byte (5))
1085     {
1086       dump_title_value_31(level);
1087       printf ("variable \"%s\"", get_string());
1088       get_string();
1089       if (!match_byte(1) && !match_byte(2))
1090         match_byte_assert(3);
1091     }
1092   else if (match_byte (2))
1093     {
1094       unsigned int format;
1095       char *var, *vallab;
1096       double value;
1097
1098       match_byte_assert (0x58);
1099       format = get_u32 ();
1100       value = get_double ();
1101       var = get_string ();
1102       vallab = get_string ();
1103       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
1104               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1105       if (!match_byte (1) && !match_byte(2))
1106         match_byte_assert (3);
1107       match_byte (0);
1108       match_byte (0);
1109       match_byte (0);
1110       match_byte (0);
1111       match_byte (0);
1112       match_byte (0);
1113       match_byte (0);
1114     }
1115   else if (match_byte (4))
1116     {
1117       unsigned int format;
1118       char *var, *vallab, *value;
1119
1120       match_byte_assert (0x58);
1121       format = get_u32 ();
1122       vallab = get_string ();
1123       var = get_string ();
1124       if (!match_byte(1) && !match_byte(2))
1125         match_byte_assert (3);
1126       value = get_string ();
1127       printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
1128               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1129       match_byte (0);
1130       match_byte (0);
1131       match_byte (0);
1132       match_byte (0);
1133     }
1134   else if (match_byte (1))
1135     {
1136       unsigned int format;
1137       double value;
1138
1139       if (match_byte (0x31))
1140         {
1141           if (match_u32 (1))
1142             {
1143               printf("(footnote %d) ", get_u32());
1144               match_byte_assert (0);
1145               match_byte_assert (0);
1146               int subn = get_u32 ();
1147               printf ("nested %d bytes", subn);
1148               pos += subn;
1149             }
1150         }
1151       else
1152         match_byte_assert (0x58);
1153       format = get_u32 ();
1154       value = get_double ();
1155       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1156       match_byte (1);
1157       match_byte (0);
1158       match_byte (0);
1159       match_byte (0);
1160       match_byte (1);
1161     }
1162   else
1163     {
1164       if (match_byte (0x31))
1165         {
1166           if (match_u32 (1))
1167             {
1168               printf("(footnote %d) ", get_u32());
1169               match_byte_assert (0);
1170               match_byte_assert (0);
1171               int subn = get_u32 ();
1172               printf ("nested %d bytes", subn);
1173               pos += subn;
1174             }
1175           else if (match_u32 (0))
1176             {
1177               match_u32_assert (0);
1178               int subn = get_u32 ();
1179               printf ("nested %d bytes", subn);
1180               pos += subn;
1181             }
1182           else
1183             {
1184               match_u32_assert(3);
1185               printf("(special 3)");
1186               match_byte_assert(0);
1187               match_byte_assert(0);
1188               match_byte_assert(1);
1189               match_byte_assert(0);
1190               int subn = get_u32 ();
1191               printf ("nested %d bytes, ", subn);
1192               pos += subn;
1193               subn = get_u32 ();
1194               printf ("nested %d bytes, ", subn);
1195               pos += subn;
1196             }
1197
1198         }
1199       else
1200         match_byte_assert (0x58);
1201
1202       char *base = get_string();
1203       int x = get_u32();
1204       printf ("\"%s\" with %d variables:\n", base, x);
1205       for (int i = 0; i < x; i++)
1206         {
1207           int y = get_u32();
1208           if (!y)
1209             y = 1;
1210           else
1211             match_u32_assert(0);
1212           for (int j = 0; j <= level; j++)
1213             printf ("    ");
1214           printf("variable %d has %d values:\n", i, y);
1215           for (int j = 0; j < y; j++)
1216             {
1217               match_byte(0);
1218               if (match_byte(3))
1219                 {
1220                   char *a = get_string();
1221                   match_byte_assert(0x58);
1222                   char *b = get_string();
1223                   char *c = get_string();
1224                   for (int k = 0; k <= level + 1; k++)
1225                     printf ("    ");
1226                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1227                 }
1228               else
1229                 dump_title_value (level+1);
1230               putchar('\n');
1231             }
1232         }
1233     }
1234 }
1235
1236 static void
1237 dump_footnote_value(int level)
1238 {
1239   for (int i = 0; i <= level; i++)
1240     printf ("    ");
1241
1242   match_byte (0);
1243   match_byte (0);
1244   match_byte (0);
1245   match_byte (0);
1246   if (match_byte (3))
1247     {
1248       get_string();
1249       if (match_byte (0x31))
1250         {
1251           if (match_u32 (1))
1252             {
1253               printf("(footnote %d) ", get_u32());
1254               match_byte_assert (0);
1255               match_byte_assert (0);
1256               int subn = get_u32 ();
1257               printf ("nested %d bytes", subn);
1258               pos += subn;
1259             }
1260           else if (match_u32 (2))
1261             {
1262               printf("(special 2)");
1263               match_byte_assert(0);
1264               match_byte_assert(0);
1265               match_u32_assert(1);
1266               match_byte_assert(0);
1267               match_byte_assert(0);
1268               int subn = get_u32 ();
1269               printf ("nested %d bytes", subn);
1270               pos += subn;
1271             }
1272           else
1273             {
1274               match_u32_assert(3);
1275               printf("(special 3)");
1276               match_byte_assert(0);
1277               match_byte_assert(0);
1278               match_byte_assert(1);
1279               match_byte_assert(0);
1280               int subn = get_u32 ();
1281               printf ("nested %d bytes, ", subn);
1282               pos += subn;
1283               subn = get_u32 ();
1284               printf ("nested %d bytes, ", subn);
1285               pos += subn;
1286             }
1287         }
1288       else
1289         match_byte_assert (0x58);
1290       get_string();
1291       printf("string \"%s\"", get_string());
1292       if (!match_byte (0))
1293         match_byte_assert (1);
1294     }
1295   else if (match_byte (5))
1296     {
1297       match_byte_assert (0x58);
1298       printf ("variable \"%s\"", get_string());
1299       get_string();
1300       if (!match_byte(1) && !match_byte(2))
1301         match_byte_assert(3);
1302     }
1303   else if (match_byte (2))
1304     {
1305       unsigned int format;
1306       char *var, *vallab;
1307       double value;
1308
1309       match_byte_assert (0x58);
1310       format = get_u32 ();
1311       value = get_double ();
1312       var = get_string ();
1313       vallab = get_string ();
1314       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
1315               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1316       if (!match_byte (1) && !match_byte(2))
1317         match_byte_assert (3);
1318       match_byte (0);
1319       match_byte (0);
1320       match_byte (0);
1321       match_byte (0);
1322       match_byte (0);
1323       match_byte (0);
1324       match_byte (0);
1325     }
1326   else if (match_byte (4))
1327     {
1328       unsigned int format;
1329       char *var, *vallab, *value;
1330
1331       match_byte_assert (0x58);
1332       format = get_u32 ();
1333       vallab = get_string ();
1334       var = get_string ();
1335       if (!match_byte(1) && !match_byte(2))
1336         match_byte_assert (3);
1337       value = get_string ();
1338       printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
1339               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1340       match_byte (0);
1341       match_byte (0);
1342       match_byte (0);
1343       match_byte (0);
1344     }
1345   else if (match_byte (1))
1346     {
1347       unsigned int format;
1348       double value;
1349
1350       if (match_byte (0x31))
1351         {
1352           if (match_u32 (1))
1353             {
1354               printf("(footnote %d) ", get_u32());
1355               match_byte_assert (0);
1356               match_byte_assert (0);
1357               int subn = get_u32 ();
1358               printf ("nested %d bytes", subn);
1359               pos += subn;
1360             }
1361         }
1362       else
1363         match_byte_assert (0x58);
1364       format = get_u32 ();
1365       value = get_double ();
1366       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1367     }
1368   else if (match_byte (0x31))
1369     {
1370       if (match_u32 (1))
1371         {
1372           printf("(footnote %d) ", get_u32());
1373           match_byte_assert (0);
1374           match_byte_assert (0);
1375           int subn = get_u32 ();
1376           printf ("nested %d bytes", subn);
1377           pos += subn;
1378         }
1379       else
1380         {
1381           match_u32_assert (0);
1382           match_u32_assert (0);
1383           int subn = get_u32 ();
1384           printf ("nested %d bytes", subn);
1385           pos += subn;
1386         }
1387       char *base = get_string();
1388       int x = get_u32();
1389       printf ("\"%s\"; %d variables:\n", base, x);
1390       for (int i = 0; i < x; i++)
1391         {
1392           int y = get_u32();
1393           if (!y)
1394             y = 1;
1395           else
1396             match_u32_assert(0);
1397           for (int j = 0; j <= level; j++)
1398             printf ("    ");
1399           printf("variable %d has %d values:\n", i, y);
1400           for (int j = 0; j < y; j++)
1401             {
1402               if (match_byte(3))
1403                 {
1404                   char *a = get_string();
1405                   match_byte_assert(0x58);
1406                   char *b = get_string();
1407                   char *c = get_string();
1408                   for (int k = 0; k <= level + 1; k++)
1409                     printf ("    ");
1410                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1411                   if (!match_byte(1))
1412                     match_byte_assert(0);
1413                 }
1414               else
1415                 dump_footnote_value (level+1);
1416               putchar('\n');
1417             }
1418         }
1419     }
1420   else
1421     {
1422
1423       match_byte_assert (0x58);
1424       char *base = get_string();
1425       int x = get_u32();
1426       printf ("\"%s\" with %d variables:\n", base, x);
1427       for (int i = 0; i < x; i++)
1428         {
1429           int y = get_u32();
1430           if (!y)
1431             y = 1;
1432           else
1433             match_u32_assert(0);
1434           for (int j = 0; j <= level; j++)
1435             printf ("    ");
1436           printf("variable %d has %d values:\n", i, y);
1437           for (int j = 0; j < y; j++)
1438             {
1439               if (match_byte(3))
1440                 {
1441                   char *a = get_string();
1442                   match_byte_assert(0x58);
1443                   char *b = get_string();
1444                   char *c = get_string();
1445                   for (int k = 0; k <= level + 1; k++)
1446                     printf ("    ");
1447                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1448                   match_byte_assert(0);
1449                 }
1450               else
1451                 dump_footnote_value (level+1);
1452               putchar('\n');
1453             }
1454         }
1455     }
1456 }
1457
1458 static void
1459 dump_title(void)
1460 {
1461   pos = 0x27;
1462   dump_title_value(0); putchar('\n');
1463   dump_title_value(0); putchar('\n');
1464   match_byte_assert(0x31);
1465   dump_title_value(0); putchar('\n');
1466   match_byte(0);
1467   match_byte_assert(0x58);
1468   if (match_byte(0x31))
1469     {
1470       dump_footnote_value(0); putchar('\n');
1471     }
1472   else
1473     match_byte_assert(0x58);
1474
1475
1476   int n_footnotes = get_u32();
1477   if (n_footnotes >= 20)
1478     {
1479       fprintf(stderr, "%08x: %d footnotes\n", pos - 4, n_footnotes);
1480       exit(1);
1481     }
1482
1483   printf("------\n%d footnotes\n", n_footnotes);
1484   if (n_footnotes < 20)
1485     {
1486       for (int i = 0; i < n_footnotes; i++)
1487         {
1488           printf("footnote %d:\n", i);
1489           dump_footnote_value(0);
1490           match_byte(0);
1491           match_byte(0);
1492           match_byte(0);
1493           match_byte(0);
1494           if (match_byte (1))
1495             {
1496               unsigned int format;
1497               double value;
1498
1499               if (match_byte (0x31))
1500                 {
1501                   if (match_u32 (1))
1502                     {
1503                       printf("(footnote %d) ", get_u32());
1504                       match_byte_assert (0);
1505                       match_byte_assert (0);
1506                       int subn = get_u32 ();
1507                       printf ("nested %d bytes", subn);
1508                       pos += subn;
1509                     }
1510                 }
1511               else
1512                 match_byte_assert (0x58);
1513               format = get_u32 ();
1514               value = get_double ();
1515               printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1516               match_byte (1);
1517               match_byte (0);
1518               match_byte (0);
1519               match_byte (0);
1520               match_byte (1);
1521             }
1522           else if (match_byte (0x31))
1523             {
1524               match_byte_assert(3);
1525               get_string();
1526               match_byte_assert(0x58);
1527               match_u32_assert(0);
1528               get_string();
1529               match_byte(0);
1530             }
1531           else
1532             match_byte_assert (0x58);
1533           printf("(%d)\n", get_u32());
1534         }
1535     }
1536 }
1537
1538 static int
1539 find_dimensions(void)
1540 {
1541   {
1542     const char dimensions[] = "-,,,.\0";
1543     int x = try_find_tail(dimensions, sizeof dimensions - 1);
1544     if (x)
1545       return x;
1546   }
1547
1548   const char dimensions[] = "-,,, .\0";
1549   return find_tail(dimensions, sizeof dimensions - 1);
1550 }
1551
1552 static void
1553 dump_fonts(void)
1554 {
1555   printf("fonts: offset=%08x\n", pos);
1556   match_byte(0);
1557   for (int i = 1; i <= 8; i++)
1558     {
1559       printf("%08x: font %d, ", pos, i);
1560       match_byte_assert(i);
1561       match_byte_assert(0x31);
1562       printf("%s, ", get_string());
1563       match_byte_assert(0);
1564       match_byte_assert(0);
1565       if (!match_byte(0x40) && !match_byte(0x20) && !match_byte(0x80) && !match_byte(0x10))
1566         match_byte_assert(0x50);
1567       if (!match_byte(0x41))
1568         match_byte_assert(0x51);
1569       pos += 13;
1570       printf ("%s, ", get_string());
1571       printf ("%s, ", get_string());
1572       match_u32_assert(0);
1573       match_u32_assert(0);
1574       pos++;
1575       get_u32();
1576       get_u32();
1577       get_u32();
1578       get_u32();
1579       putchar('\n');
1580     }
1581
1582   match_u32_assert(240);
1583   pos += 240;
1584
1585   match_u32_assert(18);
1586   pos += 18;
1587
1588   if (match_u32(117))
1589     pos += 117;
1590   else
1591     {
1592       match_u32_assert(142);
1593       pos += 142;
1594     }
1595
1596   int count = get_u32();
1597   pos += 4 * count;
1598
1599   char *encoding = get_string();
1600   printf("encoding=%s\n", encoding);
1601
1602   if (!match_u32(0))
1603     match_u32_assert(UINT32_MAX);
1604   if (!match_byte(0))
1605     match_byte_assert(1);
1606   match_byte_assert(0);
1607   if (!match_byte(0))
1608     match_byte_assert(1);
1609   if (!match_byte(0x99) && !match_byte(0x98))
1610     match_byte_assert(0x97);
1611   match_byte_assert(7);
1612   match_byte_assert(0);
1613   match_byte_assert(0);
1614   if (match_byte('.'))
1615     match_byte_assert(',');
1616   else
1617     {
1618       match_byte_assert(',');
1619       if (!match_byte('.'))
1620         match_byte_assert(' ');
1621     }
1622   match_u32_assert(5);
1623   for (int i = 0; i < 5; i++)
1624     get_string();
1625   pos += get_u32();
1626   if (pos != find_dimensions())
1627     fprintf (stderr, "%08x / %08x\n", pos, find_dimensions());
1628 }
1629
1630 int
1631 main(int argc, char *argv[])
1632 {
1633   size_t start;
1634   struct stat s;
1635
1636   if (isatty(STDIN_FILENO))
1637     {
1638       fprintf(stderr, "redirect stdin from a .bin file\n");
1639       exit(1);
1640     }
1641   if (fstat(STDIN_FILENO, &s))
1642     {
1643       perror("fstat");
1644       exit(1);
1645     }
1646   n = s.st_size;
1647   data = malloc(n);
1648   if (!data)
1649     {
1650       perror("malloc");
1651       exit(1);
1652     }
1653   if (read(STDIN_FILENO, data, n) != n)
1654     {
1655       perror("read");
1656       exit(1);
1657     }
1658
1659   if (argc > 1)
1660     {
1661       if (!strcmp(argv[1], "title0"))
1662         {
1663           pos = 0x27;
1664           if (match_byte (0x03)
1665               || (match_byte (0x05) && match_byte (0x58)))
1666             printf ("%s\n", get_string());
1667           else
1668             printf ("<unknown>\n");
1669           return 0;
1670         }
1671       else if (!strcmp(argv[1], "title"))
1672         {
1673           dump_title();
1674           exit(0);
1675         }
1676       else if (!strcmp(argv[1], "titleraw"))
1677         {
1678           const char fonts[] = "\x01\x31\x09\0\0\0SansSerif";
1679           start = 0x27;
1680           n = find(fonts, sizeof fonts - 1);
1681         }
1682       else if (!strcmp(argv[1], "fonts"))
1683         {
1684           const char fonts[] = "\x01\x31\x09\0\0\0SansSerif";
1685           const char styles[] = "\xf0\0\0\0";
1686           start = find(fonts, sizeof fonts - 1);
1687           n = find(styles, sizeof styles - 1);
1688         }
1689       else if (!strcmp(argv[1], "styles"))
1690         {
1691           const char styles[] = "\xf0\0\0\0";
1692           const char dimensions[] = "-,,,.\0";
1693           start = find(styles, sizeof styles - 1);
1694           n = find(dimensions, sizeof dimensions - 1) + sizeof dimensions - 1;
1695         }
1696       else if (!strcmp(argv[1], "dimensions") || !strcmp(argv[1], "all"))
1697         {
1698           pos = 0;
1699           match_byte_assert(1);
1700           match_byte_assert(0);
1701           match_u32_assert(3);
1702           match_byte_assert(1);
1703           if (!match_byte(0))
1704             match_byte_assert(1);
1705           match_byte_assert(0);
1706           match_byte_assert(0);
1707           if (!match_byte(0))
1708             match_byte_assert(1);
1709           pos++;
1710           match_byte_assert(0);
1711           match_byte_assert(0);
1712           match_byte_assert(0);
1713           dump_title ();
1714           dump_fonts();
1715           dump_dims ();
1716           printf("\n\ndata:\n");
1717           dump_data ();
1718           if (pos == n - 1)
1719             match_byte_assert (1);
1720           if (pos != n)
1721             {
1722               fprintf (stderr, "%x / %x\n", pos, n);
1723               exit(1);
1724             }
1725           exit(0);
1726         }
1727       else
1728         {
1729           fprintf (stderr, "unknown section %s\n", argv[1]);
1730           exit(1);
1731         }
1732     }
1733   else
1734     start = 0x27;
1735
1736   for (size_t i = start; i < n; )
1737     {
1738       if (i + 5 <= n
1739           && data[i]
1740           //&& !data[i + 1]
1741           && !data[i + 2]
1742           && !data[i + 3]
1743           && i + 4 + data[i] + data[i + 1] * 256 <= n
1744           && all_ascii(&data[i + 4], data[i] + data[i + 1] * 256))
1745         {
1746           fputs("\n\"", stdout);
1747           fwrite(&data[i + 4], 1, data[i] + data[i + 1] * 256, stdout);
1748           fputs("\" ", stdout);
1749
1750           i += 4 + data[i] + data[i + 1] * 256;
1751         }
1752       else if (i + 12 <= n
1753                && data[i + 1] == 40
1754                && data[i + 2] == 5
1755                && data[i + 3] == 0)
1756         {
1757           double d;
1758
1759           memcpy (&d, &data[i + 4], 8);
1760           printf ("F40.%d(%.*f)\n", data[i], data[i], d);
1761           i += 12;
1762         }
1763       else if (i + 12 <= n
1764                && data[i + 1] == 40
1765                && data[i + 2] == 31
1766                && data[i + 3] == 0)
1767         {
1768           double d;
1769
1770           memcpy (&d, &data[i + 4], 8);
1771           printf ("PCT40.%d(%.*f)\n", data[i], data[i], d);
1772           i += 12;
1773         }
1774       else if (i + 4 <= n
1775                && (data[i] && data[i] != 88 && data[i] != 0x41)
1776                && !data[i + 1]
1777                && !data[i + 2]
1778                && !data[i + 3])
1779         {
1780           printf ("i%d ", data[i]);
1781           i += 4;
1782         }
1783       else
1784         {
1785           printf("%02x ", data[i]);
1786           i++;
1787         }
1788     }
1789
1790   return 0;
1791 }