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(int level)
1012 {
1013   for (int i = 0; i <= level; i++)
1014     printf ("    ");
1015
1016   match_byte (0);
1017   match_byte (0);
1018   match_byte (0);
1019   match_byte (0);
1020   match_byte (0);
1021   if (match_byte (3))
1022     {
1023       get_string();
1024       if (match_byte (0x31))
1025         {
1026           if (match_u32 (1))
1027             {
1028               printf("(footnote %d) ", get_u32());
1029               match_byte_assert (0);
1030               match_byte_assert (0);
1031               int subn = get_u32 ();
1032               printf ("nested %d bytes", subn);
1033               pos += subn;
1034             }
1035           else if (match_u32 (2))
1036             {
1037               printf("(special 2)");
1038               match_byte_assert(0);
1039               match_byte_assert(0);
1040               if (!match_u32(2))
1041                 match_u32_assert(1);
1042               match_byte_assert(0);
1043               match_byte_assert(0);
1044               int subn = get_u32 ();
1045               printf ("nested %d bytes", subn);
1046               pos += subn;
1047             }
1048           else
1049             {
1050               match_u32_assert(3);
1051               printf("(special 3)");
1052               match_byte_assert(0);
1053               match_byte_assert(0);
1054               match_byte_assert(1);
1055               match_byte_assert(0);
1056               int subn = get_u32 ();
1057               printf ("nested %d bytes, ", subn);
1058               pos += subn;
1059               subn = get_u32 ();
1060               printf ("nested %d bytes, ", subn);
1061               pos += subn;
1062             }
1063         }
1064       else
1065         match_byte_assert (0x58);
1066       get_string();
1067       printf("string \"%s\"", get_string());
1068       match_byte (0);
1069       match_byte (0);
1070       match_byte (0);
1071       match_byte (1);
1072       match_byte (1);
1073       match_byte (0);
1074       match_byte (0);
1075       match_byte (0);
1076       match_byte (1);
1077     }
1078   else if (match_byte (5))
1079     {
1080       if (match_byte (0x31))
1081         {
1082           if (match_u32 (1))
1083             {
1084               printf("(footnote %d) ", get_u32());
1085               match_byte_assert (0);
1086               match_byte_assert (0);
1087               int subn = get_u32 ();
1088               printf ("nested %d bytes", subn);
1089               pos += subn;
1090             }
1091         }
1092       else
1093         match_byte_assert (0x58);
1094       printf ("variable \"%s\"", get_string());
1095       get_string();
1096       if (!match_byte(1) && !match_byte(2))
1097         match_byte_assert(3);
1098     }
1099   else if (match_byte (2))
1100     {
1101       unsigned int format;
1102       char *var, *vallab;
1103       double value;
1104
1105       match_byte_assert (0x58);
1106       format = get_u32 ();
1107       value = get_double ();
1108       var = get_string ();
1109       vallab = get_string ();
1110       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
1111               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1112       if (!match_byte (1) && !match_byte(2))
1113         match_byte_assert (3);
1114       match_byte (0);
1115       match_byte (0);
1116       match_byte (0);
1117       match_byte (0);
1118       match_byte (0);
1119       match_byte (0);
1120       match_byte (0);
1121     }
1122   else if (match_byte (4))
1123     {
1124       unsigned int format;
1125       char *var, *vallab, *value;
1126
1127       match_byte_assert (0x58);
1128       format = get_u32 ();
1129       vallab = get_string ();
1130       var = get_string ();
1131       if (!match_byte(1) && !match_byte(2))
1132         match_byte_assert (3);
1133       value = get_string ();
1134       printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
1135               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1136       match_byte (0);
1137       match_byte (0);
1138       match_byte (0);
1139       match_byte (0);
1140     }
1141   else if (match_byte (1))
1142     {
1143       unsigned int format;
1144       double value;
1145
1146       if (match_byte (0x31))
1147         {
1148           if (match_u32 (1))
1149             {
1150               printf("(footnote %d) ", get_u32());
1151               match_byte_assert (0);
1152               match_byte_assert (0);
1153               int subn = get_u32 ();
1154               printf ("nested %d bytes", subn);
1155               pos += subn;
1156             }
1157         }
1158       else
1159         match_byte_assert (0x58);
1160       format = get_u32 ();
1161       value = get_double ();
1162       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1163       match_byte (1);
1164       match_byte (0);
1165       match_byte (0);
1166       match_byte (0);
1167       match_byte (1);
1168     }
1169   else
1170     {
1171       if (match_byte (0x31))
1172         {
1173           if (match_u32 (1))
1174             {
1175               printf("(footnote %d) ", get_u32());
1176               match_byte_assert (0);
1177               match_byte_assert (0);
1178               int subn = get_u32 ();
1179               printf ("nested %d bytes", subn);
1180               pos += subn;
1181             }
1182           else if (match_u32 (0))
1183             {
1184               match_u32_assert (0);
1185               int subn = get_u32 ();
1186               printf ("nested %d bytes", subn);
1187               pos += subn;
1188             }
1189           else
1190             {
1191               match_u32_assert(3);
1192               printf("(special 3)");
1193               match_byte_assert(0);
1194               match_byte_assert(0);
1195               match_byte_assert(1);
1196               match_byte_assert(0);
1197               int subn = get_u32 ();
1198               printf ("nested %d bytes, ", subn);
1199               pos += subn;
1200               subn = get_u32 ();
1201               printf ("nested %d bytes, ", subn);
1202               pos += subn;
1203             }
1204
1205         }
1206       else
1207         match_byte_assert (0x58);
1208
1209       char *base = get_string();
1210       int x = get_u32();
1211       printf ("\"%s\" with %d variables:\n", base, x);
1212       for (int i = 0; i < x; i++)
1213         {
1214           int y = get_u32();
1215           if (!y)
1216             y = 1;
1217           else
1218             match_u32_assert(0);
1219           for (int j = 0; j <= level; j++)
1220             printf ("    ");
1221           printf("variable %d has %d values:\n", i, y);
1222           for (int j = 0; j < y; j++)
1223             {
1224               match_byte(0);
1225               if (match_byte(3))
1226                 {
1227                   char *a = get_string();
1228                   match_byte_assert(0x58);
1229                   char *b = get_string();
1230                   char *c = get_string();
1231                   for (int k = 0; k <= level + 1; k++)
1232                     printf ("    ");
1233                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1234                 }
1235               else
1236                 dump_title_value (level+1);
1237               putchar('\n');
1238             }
1239         }
1240     }
1241 }
1242
1243 static void
1244 dump_footnote_value(int level)
1245 {
1246   for (int i = 0; i <= level; i++)
1247     printf ("    ");
1248
1249   match_byte (0);
1250   match_byte (0);
1251   match_byte (0);
1252   match_byte (0);
1253   if (match_byte (3))
1254     {
1255       get_string();
1256       if (match_byte (0x31))
1257         {
1258           if (match_u32 (1))
1259             {
1260               printf("(footnote %d) ", get_u32());
1261               match_byte_assert (0);
1262               match_byte_assert (0);
1263               int subn = get_u32 ();
1264               printf ("nested %d bytes", subn);
1265               pos += subn;
1266             }
1267           else if (match_u32 (2))
1268             {
1269               printf("(special 2)");
1270               match_byte_assert(0);
1271               match_byte_assert(0);
1272               match_u32_assert(1);
1273               match_byte_assert(0);
1274               match_byte_assert(0);
1275               int subn = get_u32 ();
1276               printf ("nested %d bytes", subn);
1277               pos += subn;
1278             }
1279           else
1280             {
1281               match_u32_assert(3);
1282               printf("(special 3)");
1283               match_byte_assert(0);
1284               match_byte_assert(0);
1285               match_byte_assert(1);
1286               match_byte_assert(0);
1287               int subn = get_u32 ();
1288               printf ("nested %d bytes, ", subn);
1289               pos += subn;
1290               subn = get_u32 ();
1291               printf ("nested %d bytes, ", subn);
1292               pos += subn;
1293             }
1294         }
1295       else
1296         match_byte_assert (0x58);
1297       get_string();
1298       printf("string \"%s\"", get_string());
1299       if (!match_byte (0))
1300         match_byte_assert (1);
1301     }
1302   else if (match_byte (5))
1303     {
1304       match_byte_assert (0x58);
1305       printf ("variable \"%s\"", get_string());
1306       get_string();
1307       if (!match_byte(1) && !match_byte(2))
1308         match_byte_assert(3);
1309     }
1310   else if (match_byte (2))
1311     {
1312       unsigned int format;
1313       char *var, *vallab;
1314       double value;
1315
1316       match_byte_assert (0x58);
1317       format = get_u32 ();
1318       value = get_double ();
1319       var = get_string ();
1320       vallab = get_string ();
1321       printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"",
1322               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1323       if (!match_byte (1) && !match_byte(2))
1324         match_byte_assert (3);
1325       match_byte (0);
1326       match_byte (0);
1327       match_byte (0);
1328       match_byte (0);
1329       match_byte (0);
1330       match_byte (0);
1331       match_byte (0);
1332     }
1333   else if (match_byte (4))
1334     {
1335       unsigned int format;
1336       char *var, *vallab, *value;
1337
1338       match_byte_assert (0x58);
1339       format = get_u32 ();
1340       vallab = get_string ();
1341       var = get_string ();
1342       if (!match_byte(1) && !match_byte(2))
1343         match_byte_assert (3);
1344       value = get_string ();
1345       printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"",
1346               value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab);
1347       match_byte (0);
1348       match_byte (0);
1349       match_byte (0);
1350       match_byte (0);
1351     }
1352   else if (match_byte (1))
1353     {
1354       unsigned int format;
1355       double value;
1356
1357       if (match_byte (0x31))
1358         {
1359           if (match_u32 (1))
1360             {
1361               printf("(footnote %d) ", get_u32());
1362               match_byte_assert (0);
1363               match_byte_assert (0);
1364               int subn = get_u32 ();
1365               printf ("nested %d bytes", subn);
1366               pos += subn;
1367             }
1368         }
1369       else
1370         match_byte_assert (0x58);
1371       format = get_u32 ();
1372       value = get_double ();
1373       printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1374     }
1375   else if (match_byte (0x31))
1376     {
1377       if (match_u32 (1))
1378         {
1379           printf("(footnote %d) ", get_u32());
1380           match_byte_assert (0);
1381           match_byte_assert (0);
1382           int subn = get_u32 ();
1383           printf ("nested %d bytes", subn);
1384           pos += subn;
1385         }
1386       else
1387         {
1388           match_u32_assert (0);
1389           match_u32_assert (0);
1390           int subn = get_u32 ();
1391           printf ("nested %d bytes", subn);
1392           pos += subn;
1393         }
1394       char *base = get_string();
1395       int x = get_u32();
1396       printf ("\"%s\"; %d variables:\n", base, x);
1397       for (int i = 0; i < x; i++)
1398         {
1399           int y = get_u32();
1400           if (!y)
1401             y = 1;
1402           else
1403             match_u32_assert(0);
1404           for (int j = 0; j <= level; j++)
1405             printf ("    ");
1406           printf("variable %d has %d values:\n", i, y);
1407           for (int j = 0; j < y; j++)
1408             {
1409               if (match_byte(3))
1410                 {
1411                   char *a = get_string();
1412                   match_byte_assert(0x58);
1413                   char *b = get_string();
1414                   char *c = get_string();
1415                   for (int k = 0; k <= level + 1; k++)
1416                     printf ("    ");
1417                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1418                   if (!match_byte(1))
1419                     match_byte_assert(0);
1420                 }
1421               else
1422                 dump_footnote_value (level+1);
1423               putchar('\n');
1424             }
1425         }
1426     }
1427   else
1428     {
1429
1430       match_byte_assert (0x58);
1431       char *base = get_string();
1432       int x = get_u32();
1433       printf ("\"%s\" with %d variables:\n", base, x);
1434       for (int i = 0; i < x; i++)
1435         {
1436           int y = get_u32();
1437           if (!y)
1438             y = 1;
1439           else
1440             match_u32_assert(0);
1441           for (int j = 0; j <= level; j++)
1442             printf ("    ");
1443           printf("variable %d has %d values:\n", i, y);
1444           for (int j = 0; j < y; j++)
1445             {
1446               if (match_byte(3))
1447                 {
1448                   char *a = get_string();
1449                   match_byte_assert(0x58);
1450                   char *b = get_string();
1451                   char *c = get_string();
1452                   for (int k = 0; k <= level + 1; k++)
1453                     printf ("    ");
1454                   printf ("\"%s\", \"%s\", \"%s\"", a, b, c);
1455                   match_byte_assert(0);
1456                 }
1457               else
1458                 dump_footnote_value (level+1);
1459               putchar('\n');
1460             }
1461         }
1462     }
1463 }
1464
1465 static void
1466 dump_title(void)
1467 {
1468   pos = 0x27;
1469   dump_title_value(0); putchar('\n');
1470   dump_title_value(0); putchar('\n');
1471   match_byte_assert(0x31);
1472   dump_title_value(0); putchar('\n');
1473   match_byte(0);
1474   match_byte_assert(0x58);
1475   if (match_byte(0x31))
1476     {
1477       dump_footnote_value(0); putchar('\n');
1478     }
1479   else
1480     match_byte_assert(0x58);
1481
1482
1483   int n_footnotes = get_u32();
1484   if (n_footnotes >= 20)
1485     {
1486       fprintf(stderr, "%08x: %d footnotes\n", pos - 4, n_footnotes);
1487       exit(1);
1488     }
1489
1490   printf("------\n%d footnotes\n", n_footnotes);
1491   if (n_footnotes < 20)
1492     {
1493       for (int i = 0; i < n_footnotes; i++)
1494         {
1495           printf("footnote %d:\n", i);
1496           dump_footnote_value(0);
1497           match_byte(0);
1498           match_byte(0);
1499           match_byte(0);
1500           match_byte(0);
1501           if (match_byte (1))
1502             {
1503               unsigned int format;
1504               double value;
1505
1506               if (match_byte (0x31))
1507                 {
1508                   if (match_u32 (1))
1509                     {
1510                       printf("(footnote %d) ", get_u32());
1511                       match_byte_assert (0);
1512                       match_byte_assert (0);
1513                       int subn = get_u32 ();
1514                       printf ("nested %d bytes", subn);
1515                       pos += subn;
1516                     }
1517                 }
1518               else
1519                 match_byte_assert (0x58);
1520               format = get_u32 ();
1521               value = get_double ();
1522               printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff);
1523               match_byte (1);
1524               match_byte (0);
1525               match_byte (0);
1526               match_byte (0);
1527               match_byte (1);
1528             }
1529           else if (match_byte (0x31))
1530             {
1531               match_byte_assert(3);
1532               get_string();
1533               match_byte_assert(0x58);
1534               match_u32_assert(0);
1535               get_string();
1536               match_byte(0);
1537             }
1538           else
1539             match_byte_assert (0x58);
1540           printf("(%d)\n", get_u32());
1541         }
1542     }
1543 }
1544
1545 static int
1546 find_dimensions(void)
1547 {
1548   {
1549     const char dimensions[] = "-,,,.\0";
1550     int x = try_find_tail(dimensions, sizeof dimensions - 1);
1551     if (x)
1552       return x;
1553   }
1554
1555   const char dimensions[] = "-,,, .\0";
1556   return find_tail(dimensions, sizeof dimensions - 1);
1557 }
1558
1559 static void
1560 dump_fonts(void)
1561 {
1562   printf("fonts: offset=%08x\n", pos);
1563   match_byte(0);
1564   for (int i = 1; i <= 8; i++)
1565     {
1566       printf("%08x: font %d, ", pos, i);
1567       match_byte_assert(i);
1568       match_byte_assert(0x31);
1569       printf("%s, ", get_string());
1570       match_byte_assert(0);
1571       match_byte_assert(0);
1572       if (!match_byte(0x40) && !match_byte(0x20) && !match_byte(0x80) && !match_byte(0x10))
1573         match_byte_assert(0x50);
1574       if (!match_byte(0x41))
1575         match_byte_assert(0x51);
1576       pos += 13;
1577       printf ("%s, ", get_string());
1578       printf ("%s, ", get_string());
1579       match_u32_assert(0);
1580       match_u32_assert(0);
1581       pos++;
1582       get_u32();
1583       get_u32();
1584       get_u32();
1585       get_u32();
1586       putchar('\n');
1587     }
1588
1589   match_u32_assert(240);
1590   pos += 240;
1591
1592   match_u32_assert(18);
1593   pos += 18;
1594
1595   if (match_u32(117))
1596     pos += 117;
1597   else
1598     {
1599       match_u32_assert(142);
1600       pos += 142;
1601     }
1602
1603   int count = get_u32();
1604   pos += 4 * count;
1605
1606   char *encoding = get_string();
1607   printf("encoding=%s\n", encoding);
1608
1609   if (!match_u32(0))
1610     match_u32_assert(UINT32_MAX);
1611   if (!match_byte(0))
1612     match_byte_assert(1);
1613   match_byte_assert(0);
1614   if (!match_byte(0))
1615     match_byte_assert(1);
1616   if (!match_byte(0x99) && !match_byte(0x98))
1617     match_byte_assert(0x97);
1618   match_byte_assert(7);
1619   match_byte_assert(0);
1620   match_byte_assert(0);
1621   if (match_byte('.'))
1622     match_byte_assert(',');
1623   else
1624     {
1625       match_byte_assert(',');
1626       if (!match_byte('.'))
1627         match_byte_assert(' ');
1628     }
1629   match_u32_assert(5);
1630   for (int i = 0; i < 5; i++)
1631     get_string();
1632   pos += get_u32();
1633   if (pos != find_dimensions())
1634     fprintf (stderr, "%08x / %08x\n", pos, find_dimensions());
1635 }
1636
1637 int
1638 main(int argc, char *argv[])
1639 {
1640   size_t start;
1641   struct stat s;
1642
1643   if (isatty(STDIN_FILENO))
1644     {
1645       fprintf(stderr, "redirect stdin from a .bin file\n");
1646       exit(1);
1647     }
1648   if (fstat(STDIN_FILENO, &s))
1649     {
1650       perror("fstat");
1651       exit(1);
1652     }
1653   n = s.st_size;
1654   data = malloc(n);
1655   if (!data)
1656     {
1657       perror("malloc");
1658       exit(1);
1659     }
1660   if (read(STDIN_FILENO, data, n) != n)
1661     {
1662       perror("read");
1663       exit(1);
1664     }
1665
1666   if (argc > 1)
1667     {
1668       if (!strcmp(argv[1], "title0"))
1669         {
1670           pos = 0x27;
1671           if (match_byte (0x03)
1672               || (match_byte (0x05) && match_byte (0x58)))
1673             printf ("%s\n", get_string());
1674           else
1675             printf ("<unknown>\n");
1676           return 0;
1677         }
1678       else if (!strcmp(argv[1], "title"))
1679         {
1680           dump_title();
1681           exit(0);
1682         }
1683       else if (!strcmp(argv[1], "titleraw"))
1684         {
1685           const char fonts[] = "\x01\x31\x09\0\0\0SansSerif";
1686           start = 0x27;
1687           n = find(fonts, sizeof fonts - 1);
1688         }
1689       else if (!strcmp(argv[1], "fonts"))
1690         {
1691           const char fonts[] = "\x01\x31\x09\0\0\0SansSerif";
1692           const char styles[] = "\xf0\0\0\0";
1693           start = find(fonts, sizeof fonts - 1);
1694           n = find(styles, sizeof styles - 1);
1695         }
1696       else if (!strcmp(argv[1], "styles"))
1697         {
1698           const char styles[] = "\xf0\0\0\0";
1699           const char dimensions[] = "-,,,.\0";
1700           start = find(styles, sizeof styles - 1);
1701           n = find(dimensions, sizeof dimensions - 1) + sizeof dimensions - 1;
1702         }
1703       else if (!strcmp(argv[1], "dimensions") || !strcmp(argv[1], "all"))
1704         {
1705           pos = 0;
1706           match_byte_assert(1);
1707           match_byte_assert(0);
1708           match_u32_assert(3);
1709           match_byte_assert(1);
1710           if (!match_byte(0))
1711             match_byte_assert(1);
1712           match_byte_assert(0);
1713           match_byte_assert(0);
1714           if (!match_byte(0))
1715             match_byte_assert(1);
1716           pos++;
1717           match_byte_assert(0);
1718           match_byte_assert(0);
1719           match_byte_assert(0);
1720           dump_title ();
1721           dump_fonts();
1722           dump_dims ();
1723           printf("\n\ndata:\n");
1724           dump_data ();
1725           if (pos == n - 1)
1726             match_byte_assert (1);
1727           if (pos != n)
1728             {
1729               fprintf (stderr, "%x / %x\n", pos, n);
1730               exit(1);
1731             }
1732           exit(0);
1733         }
1734       else
1735         {
1736           fprintf (stderr, "unknown section %s\n", argv[1]);
1737           exit(1);
1738         }
1739     }
1740   else
1741     start = 0x27;
1742
1743   for (size_t i = start; i < n; )
1744     {
1745       if (i + 5 <= n
1746           && data[i]
1747           //&& !data[i + 1]
1748           && !data[i + 2]
1749           && !data[i + 3]
1750           && i + 4 + data[i] + data[i + 1] * 256 <= n
1751           && all_ascii(&data[i + 4], data[i] + data[i + 1] * 256))
1752         {
1753           fputs("\n\"", stdout);
1754           fwrite(&data[i + 4], 1, data[i] + data[i + 1] * 256, stdout);
1755           fputs("\" ", stdout);
1756
1757           i += 4 + data[i] + data[i + 1] * 256;
1758         }
1759       else if (i + 12 <= n
1760                && data[i + 1] == 40
1761                && data[i + 2] == 5
1762                && data[i + 3] == 0)
1763         {
1764           double d;
1765
1766           memcpy (&d, &data[i + 4], 8);
1767           printf ("F40.%d(%.*f)\n", data[i], data[i], d);
1768           i += 12;
1769         }
1770       else if (i + 12 <= n
1771                && data[i + 1] == 40
1772                && data[i + 2] == 31
1773                && data[i + 3] == 0)
1774         {
1775           double d;
1776
1777           memcpy (&d, &data[i + 4], 8);
1778           printf ("PCT40.%d(%.*f)\n", data[i], data[i], d);
1779           i += 12;
1780         }
1781       else if (i + 4 <= n
1782                && (data[i] && data[i] != 88 && data[i] != 0x41)
1783                && !data[i + 1]
1784                && !data[i + 2]
1785                && !data[i + 3])
1786         {
1787           printf ("i%d ", data[i]);
1788           i += 4;
1789         }
1790       else
1791         {
1792           printf("%02x ", data[i]);
1793           i++;
1794         }
1795     }
1796
1797   return 0;
1798 }