X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=dump.c;h=7f3c2b8c75174a045f9666ff379af99efaef5aa3;hb=refs%2Fheads%2Fspv;hp=830a5dac1dc3714ea57c2b5429651ff560d66b67;hpb=8f03a15bc9fce38e9651dcb3ce82ba7815ccc9b5;p=pspp diff --git a/dump.c b/dump.c index 830a5dac1d..7f3c2b8c75 100644 --- a/dump.c +++ b/dump.c @@ -1,4 +1,6 @@ #include +#include +#include #include #include #include @@ -6,57 +8,64 @@ #include #include #include +#include #include #include "u8-mbtouc.h" +static const char *filename; static uint8_t *data; static size_t n; int version; -static bool -all_ascii(const uint8_t *p, size_t n) +size_t pos; + +#define XSTR(x) #x +#define STR(x) XSTR(x) +#define WHERE __FILE__":" STR(__LINE__) + +static uint8_t +get_byte(void) { - for (size_t i = 0; i < n; i++) - if (p[i] < 32 || p[i] > 126) - return false; - return true; + return data[pos++]; } -static size_t -try_find(const char *target, size_t target_len) +static unsigned int +get_u32(void) { - const uint8_t *pos = (const uint8_t *) memmem (data, n, target, target_len); - return pos ? pos - data : 0; + uint32_t x; + memcpy(&x, &data[pos], 4); + pos += 4; + return x; } -static size_t -find(const char *target, size_t target_len) +static unsigned long long int +get_u64(void) { - size_t pos = try_find(target, target_len); - if (!pos) - { - fprintf (stderr, "not found\n"); - exit(1); - } - return pos; + uint64_t x; + memcpy(&x, &data[pos], 8); + pos += 8; + return x; } -size_t pos; - -#define XSTR(x) #x -#define STR(x) XSTR(x) -#define WHERE __FILE__":" STR(__LINE__) - static unsigned int -get_u32(void) +get_be32(void) { uint32_t x; - memcpy(&x, &data[pos], 4); + x = (data[pos] << 24) | (data[pos + 1] << 16) | (data[pos + 2] << 8) | data[pos + 3]; pos += 4; return x; } +static unsigned int +get_u16(void) +{ + uint16_t x; + memcpy(&x, &data[pos], 2); + pos += 2; + return x; +} + static double get_double(void) { @@ -66,6 +75,15 @@ get_double(void) return x; } +static double __attribute__((unused)) +get_float(void) +{ + float x; + memcpy(&x, &data[pos], 4); + pos += 4; + return x; +} + static bool match_u32(uint32_t x) { @@ -87,6 +105,48 @@ match_u32_assert(uint32_t x, const char *where) } #define match_u32_assert(x) match_u32_assert(x, WHERE) +static bool __attribute__((unused)) +match_u64(uint64_t x) +{ + if (get_u64() == x) + return true; + pos -= 8; + return false; +} + +static void __attribute__((unused)) +match_u64_assert(uint64_t x, const char *where) +{ + unsigned long long int y = get_u64(); + if (x != y) + { + fprintf(stderr, "%s: 0x%x: expected u64:%llu, got u64:%llu\n", where, pos - 8, x, y); + exit(1); + } +} +#define match_u64_assert(x) match_u64_assert(x, WHERE) + +static bool __attribute__((unused)) +match_be32(uint32_t x) +{ + if (get_be32() == x) + return true; + pos -= 4; + return false; +} + +static void +match_be32_assert(uint32_t x, const char *where) +{ + unsigned int y = get_be32(); + if (x != y) + { + fprintf(stderr, "%s: 0x%x: expected be%u, got be%u\n", where, pos - 4, x, y); + exit(1); + } +} +#define match_be32_assert(x) match_be32_assert(x, WHERE) + static bool match_byte(uint8_t b) { @@ -110,73 +170,13 @@ match_byte_assert(uint8_t b, const char *where) } #define match_byte_assert(b) match_byte_assert(b, WHERE) -static void -newline(FILE *stream, int pos) -{ - fprintf(stream, "\n%08x: ", pos); -} - -static void -dump_raw(FILE *stream, int start, int end) +static bool +get_bool(void) { - for (size_t i = start; i < end; ) - { - if (i + 5 <= n - && data[i] - //&& !data[i + 1] - && !data[i + 2] - && !data[i + 3] - && i + 4 + data[i] + data[i + 1] * 256 <= end - && all_ascii(&data[i + 4], data[i] + data[i + 1] * 256)) - { - newline(stream, i); - fprintf(stream, "\""); - fwrite(&data[i + 4], 1, data[i] + data[i + 1] * 256, stream); - fputs("\" ", stream); - - i += 4 + data[i] + data[i + 1] * 256; - } - else if (i + 12 <= end - && data[i + 1] == 40 - && data[i + 2] == 5 - && data[i + 3] == 0) - { - double d; - - memcpy (&d, &data[i + 4], 8); - fprintf (stream, "F40.%d(%.*f)", data[i], data[i], d); - i += 12; - newline (stream, i); - } - else if (i + 12 <= end - && data[i + 1] == 40 - && data[i + 2] == 31 - && data[i + 3] == 0) - { - double d; - - memcpy (&d, &data[i + 4], 8); - fprintf (stream, "PCT40.%d(%.*f)", data[i], data[i], d); - i += 12; - newline(stream, i); - } - else if (i + 4 <= end - && (data[i] && data[i] != 88 && data[i] != 0x41) - && !data[i + 1] - && !data[i + 2] - && !data[i + 3]) - { - fprintf (stream, "i%d ", data[i]); - i += 4; - } - else - { - fprintf(stream, "%02x ", data[i]); - i++; - } - } - - + if (match_byte(0)) + return false; + match_byte_assert(1); + return true; } static bool __attribute__((unused)) @@ -219,28 +219,149 @@ get_string(const char *where) #define get_string() get_string(WHERE) static char * -dump_nested_string(void) +get_string_be(const char *where) { - char *s = NULL; + if (1 + /*data[pos + 1] == 0 && data[pos + 2] == 0 && data[pos + 3] == 0*/ + /*&& all_ascii(&data[pos + 4], data[pos])*/) + { + int len = data[pos + 2] * 256 + data[pos + 3]; + char *s = malloc(len + 1); - match_byte_assert (0); - match_byte_assert (0); - int outer_end = pos + get_u32(); - int inner_end = pos + get_u32(); - if (pos != inner_end) + memcpy(s, &data[pos + 4], len); + s[len] = 0; + pos += 4 + len; + return s; + } + else { - match_u32_assert(0); - if (match_byte(0x31)) - s = get_string(); + fprintf(stderr, "%s: 0x%x: expected string\n", where, pos); + exit(1); + } +} +#define get_string_be() get_string_be(WHERE) + +static int +get_end(void) +{ + int len = get_u32(); + return pos + len; +} + +static void __attribute__((unused)) +hex_dump(FILE *stream, int ofs, int n) +{ + for (int i = 0; i < n; i++) + { + int c = data[ofs + i]; +#if 1 + if (i && !(i % 16)) + putc('-', stream); else - match_byte_assert(0x58); - if (pos != inner_end) - { - fprintf(stderr, "inner end discrepancy\n"); - exit(1); - } + putc(' ', stream); +#endif + fprintf(stream, "%02x", c); } - match_byte_assert(0x58); + for (int i = 0; i < n; i++) + { + int c = data[ofs + i]; + putc(c >= 32 && c < 127 ? c : '.', stream); + } + putc('\n', stream); +} + +static char * +dump_counted_string(void) +{ + int inner_end = get_end(); + if (pos == inner_end) + return NULL; + + if (match_u32(5)) + { + match_u32_assert(0); + match_byte_assert(0x58); + } + else + match_u32_assert(0); + + char *s = NULL; + if (match_byte(0x31)) + s = get_string(); + else + match_byte_assert(0x58); + if (pos != inner_end) + { + fprintf(stderr, "inner end discrepancy\n"); + exit(1); + } + return s; +} + +static void +dump_style(FILE *stream) +{ + if (match_byte(0x58)) + return; + + match_byte_assert(0x31); + if (get_bool()) + printf (" bold=\"yes\""); + if (get_bool()) + printf (" italic=\"yes\""); + if (get_bool()) + printf (" underline=\"yes\""); + if (!get_bool()) + printf (" show=\"no\""); + char *fg = get_string(); /* foreground */ + char *bg = get_string(); /* background */ + char *font = get_string(); /* font */ + int size = get_byte() * (72. / 96.); + fprintf(stream, " fgcolor=\"%s\" bgcolor=\"%s\" font=\"%s\" size=\"%dpt\"", + fg, bg, font, size); +} + +static void +dump_style2(FILE *stream) +{ + if (match_byte(0x58)) + return; + + match_byte_assert(0x31); + uint32_t halign = get_u32(); + printf (" halign=\"%s\"", + halign == 0 ? "center" + : halign == 2 ? "left" + : halign == 4 ? "right" + : halign == 6 ? "decimal" + : halign == 0xffffffad ? "mixed" + : ""); + int valign = get_u32(); + printf (" valign=\"%s\"", + valign == 0 ? "center" + : valign == 1 ? "top" + : valign == 3 ? "bottom" + : ""); + printf (" offset=\"%gpt\"", get_double()); + int l = get_u16(); + int r = get_u16(); + int t = get_u16(); + int b = get_u16(); + printf (" margins=\"%d %d %d %d\"", l, r, t, b); +} + +static char * +dump_nested_string(FILE *stream) +{ + char *s = NULL; + + match_byte_assert (0); + match_byte_assert (0); + int outer_end = get_end(); + s = dump_counted_string(); + if (s) + fprintf(stream, " \"%s\"", s); + dump_style(stream); match_byte_assert(0x58); if (pos != outer_end) { @@ -252,16 +373,23 @@ dump_nested_string(void) } static void -dump_optional_value(FILE *stream) +dump_value_modifier(FILE *stream) { if (match_byte (0x31)) { if (match_u32 (0)) { + fprintf(stream, "\n"); return; } - int outer_end = pos + get_u32(); - int inner_end = pos + get_u32(); - if (pos != inner_end) - { - match_u32_assert(0); - if (match_byte(0x31)) - { - /* Appears to be a template string, e.g. '^1 cells (^2) expf < 5. Min exp = ^3...'. - Probably doesn't actually appear in output because many examples look unpolished, - e.g. 'partial list cases value ^1 shown upper...' */ - get_string(); - } - else - match_byte_assert(0x58); - if (pos != inner_end) - { - fprintf(stderr, "inner end discrepancy\n"); - exit(1); - } - } + int outer_end = get_end(); + + /* This counted-string appears to be a template string, + e.g. "Design\: [:^1:]1 Within Subjects Design\: [:^1:]2". */ + char *template = dump_counted_string(); + if (template) + fprintf(stream, " template=\"%s\"", template); - if (match_byte(0x31)) - { - /* Only one example in the corpus. */ - match_byte(1); - match_byte(0); - match_byte(0); - match_byte(0); - match_byte_assert(1); - get_string(); /* foreground */ - get_string(); /* background */ - get_string(); /* font */ - if (!match_byte(14)) - match_byte_assert(12); /* size? */ - } - else - match_byte_assert(0x58); - if (match_byte(0x31)) - { - /* Only two SPV files have anything like this, so it's hard to - generalize. */ - match_u32_assert(0); - match_u32_assert(0); - match_u32_assert(0); - match_u32_assert(0); - match_byte_assert(1); - match_byte_assert(0); - if (!match_byte(8) && !match_byte(1)) - match_byte_assert(2); - match_byte_assert(0); - match_byte_assert(8); - match_byte_assert(0); - match_byte_assert(10); - match_byte_assert(0); - } - else - match_byte_assert(0x58); + dump_style(stream); + dump_style2(stream); if (pos != outer_end) { fprintf(stderr, "outer end discrepancy\n"); exit(1); } - } - else if (match_u32 (1)) - { - fprintf(stream, "(footnote %d) ", get_u32()); - dump_nested_string(); - } - else if (match_u32 (2)) - { - fprintf(stream, "(special 2)"); - if (!match_byte(0)) - match_byte_assert(2); - match_byte_assert(0); - if (!match_u32 (2) && !match_u32(1)) - match_u32_assert(3); - dump_nested_string(); /* Our corpus doesn't contain any examples with strings though. */ + fprintf(stream, "/>\n"); } else { - match_u32_assert(3); - fprintf(stream, "(special 3)"); - match_byte_assert(0); + int count = get_u32(); + fprintf(stream, "\n"); } } else @@ -435,32 +508,17 @@ dump_value(FILE *stream, int level) for (int i = 0; i <= level; i++) fprintf (stream, " "); - if (match_byte (3)) + printf ("%02x: value (%d)\n", pos, data[pos]); + if (match_byte (1)) { - char *text = get_string(); - dump_optional_value(stream); - char *identifier = get_string(); - char *text_eng = get_string(); - fprintf (stream, "\n"); - if (!match_byte (0)) - match_byte_assert(1); - } - else if (match_byte (5)) - { - dump_optional_value(stream); - char *name = get_string (); - char *label = get_string (); - fprintf (stream, "\n"); - if (!match_byte(1) && !match_byte(2)) - match_byte_assert(3); + unsigned int format; + double value; + + dump_value_modifier(stream); + format = get_u32 (); + value = get_double (); + fprintf (stream, "\n", + DBL_DIG, value, format_to_string(format >> 16), (format >> 8) & 0xff, format & 0xff); } else if (match_byte (2)) { @@ -468,7 +526,7 @@ dump_value(FILE *stream, int level) char *var, *vallab; double value; - dump_optional_value (stream); + dump_value_modifier (stream); format = get_u32 (); value = get_double (); var = get_string (); @@ -478,17 +536,32 @@ dump_value(FILE *stream, int level) if (var[0]) fprintf (stream, " variable=\"%s\"", var); if (vallab[0]) - fprintf (stream, " label=\"%s\"/>\n", vallab); + fprintf (stream, " label=\"%s\"", vallab); fprintf (stream, "/>\n"); if (!match_byte (1) && !match_byte(2)) match_byte_assert (3); } + else if (match_byte (3)) + { + char *text = get_string(); + dump_value_modifier(stream); + char *identifier = get_string(); + char *text_eng = get_string(); + fprintf (stream, "\n"); + if (!match_byte (0)) + match_byte_assert(1); + } else if (match_byte (4)) { unsigned int format; char *var, *vallab, *value; - match_byte_assert (0x58); + dump_value_modifier(stream); format = get_u32 (); vallab = get_string (); var = get_string (); @@ -503,20 +576,22 @@ dump_value(FILE *stream, int level) fprintf (stream, " label=\"%s\"/>\n", vallab); fprintf (stream, "/>\n"); } - else if (match_byte (1)) + else if (match_byte (5)) { - unsigned int format; - double value; - - dump_optional_value(stream); - format = get_u32 (); - value = get_double (); - fprintf (stream, "\n", - DBL_DIG, value, format_to_string(format >> 16), (format >> 8) & 0xff, format & 0xff); + dump_value_modifier(stream); + char *name = get_string (); + char *label = get_string (); + fprintf (stream, "\n"); + if (!match_byte(1) && !match_byte(2)) + match_byte_assert(3); } else { - dump_optional_value(stream); + printf ("else %#x\n", pos); + dump_value_modifier(stream); char *base = get_string(); int x = get_u32(); @@ -569,59 +644,63 @@ check_permutation(int *a, int n, const char *name) } static void -dump_category(int level, int *indexes, int *n_indexes, int max_indexes) +dump_category(FILE *stream, int level, int **indexes, int *allocated_indexes, + int *n_indexes) { for (int i = 0; i <= level; i++) - fprintf (stdout, " "); + fprintf (stream, " "); printf ("\n"); - dump_value (stdout, level + 1); - match_byte(1); - match_byte(0); - match_byte(0); - match_byte(0); + dump_value (stream, level + 1); - if (match_u32 (1)) - match_byte (0); - else if (match_byte (1)) - { - match_byte (0); - if (!match_u32 (2)) - match_u32_assert (1); - match_byte (0); - } - else if (!match_u32(2)) - match_u32_assert (0); + bool merge = get_bool(); + match_byte_assert (0); + int unindexed = get_bool(); + + int x = get_u32 (); + pos -= 4; + if (!match_u32 (0)) + match_u32_assert (2); int indx = get_u32(); int n_categories = get_u32(); - if (indx != -1) + if (indx == -1) { - if (n_categories != 0) + if (merge) { - fprintf(stderr, "index not -1 but subcategories\n"); - exit(1); + for (int i = 0; i <= level + 1; i++) + fprintf (stream, " "); + fprintf (stream, "\n"); } - if (*n_indexes >= max_indexes) + assert (unindexed); + } + else + { + assert (!merge); + assert (!unindexed); + assert (x == 2); + assert (n_categories == 0); + if (*n_indexes >= *allocated_indexes) { - fprintf(stderr, "too many categories (increase max_indexes)\n"); - exit(1); + *allocated_indexes = *allocated_indexes ? 2 * *allocated_indexes : 16; + *indexes = realloc(*indexes, *allocated_indexes * sizeof **indexes); } - indexes[(*n_indexes)++] = indx; + (*indexes)[(*n_indexes)++] = indx; } + if (n_categories == 0) { for (int i = 0; i <= level + 1; i++) - fprintf (stdout, " "); - fprintf (stdout, "%d\n", indx); + fprintf (stream, " "); + fprintf (stream, "%d\n", indx); } for (int i = 0; i < n_categories; i++) - dump_category (level + 1, indexes, n_indexes, max_indexes); + dump_category (stream, level + 1, indexes, allocated_indexes, n_indexes); for (int i = 0; i <= level; i++) - fprintf (stdout, " "); + fprintf (stream, " "); printf ("\n"); } -static void +static int dump_dim(int indx) { int n_categories; @@ -629,59 +708,93 @@ dump_dim(int indx) printf ("\n", indx); dump_value (stdout, 0); - /* This byte is usually 0x02 but many other values have been spotted. */ + /* This byte is usually 0 but many other values have been spotted. + No visible effect. */ pos++; + /* This byte can cause data to be oddly replicated. */ if (!match_byte(0) && !match_byte(1)) match_byte_assert(2); + if (!match_u32(0)) match_u32_assert(2); - if (!match_byte(0)) - match_byte_assert(1); - if (!match_byte(0)) - match_byte_assert(1); + + bool show_dim_label = get_bool(); + if (show_dim_label) + printf(" \n"); + + bool hide_all_labels = get_bool(); + if (hide_all_labels) + printf(" \n"); + match_byte_assert(1); if (!match_u32(UINT32_MAX)) match_u32_assert(indx); + n_categories = get_u32(); - int indexes[2048]; + int *indexes = NULL; int n_indexes = 0; + int allocated_indexes = 0; for (int i = 0; i < n_categories; i++) - dump_category (0, indexes, &n_indexes, sizeof indexes / sizeof *indexes); + dump_category (stdout, 0, &indexes, &allocated_indexes, &n_indexes); check_permutation(indexes, n_indexes, "categories"); fprintf (stdout, "\n"); + return n_indexes; } int n_dims; +static int dim_n_cats[64]; +#define MAX_DIMS (sizeof dim_n_cats / sizeof *dim_n_cats) + static void dump_dims(void) { n_dims = get_u32(); + assert(n_dims < MAX_DIMS); for (int i = 0; i < n_dims; i++) - dump_dim (i); + dim_n_cats[i] = dump_dim (i); } static void dump_data(void) { /* The first three numbers add to the number of dimensions. */ - int t = get_u32(); - t += get_u32(); - match_u32_assert(n_dims - t); + int l = get_u32(); + int r = get_u32(); + int c = n_dims - l - r; + match_u32_assert(c); /* The next n_dims numbers are a permutation of the dimension numbers. */ int a[n_dims]; for (int i = 0; i < n_dims; i++) - a[i] = get_u32(); + { + int dim = get_u32(); + a[i] = dim; + + const char *name = i < l ? "layer" : i < l + r ? "row" : "column"; + printf ("<%s dimension=\"%d\"/>\n", name, dim); + } check_permutation(a, n_dims, "dimensions"); int x = get_u32(); printf ("\n"); for (int i = 0; i < x; i++) { - printf (" \n", get_u32()); + unsigned int indx = get_u32(); + printf (" \n"); match_u32_assert(0); if (version == 1) match_byte(0); @@ -711,8 +824,14 @@ dump_title(void) match_byte(1); printf ("\n"); - match_byte(0); - match_byte_assert(0x58); + if (match_byte(0x31)) + { + printf ("\n"); + dump_value(stdout, 0); + printf ("\n"); + } + else + match_byte_assert(0x58); if (match_byte(0x31)) { printf ("\n"); @@ -732,7 +851,19 @@ dump_title(void) dump_value(stdout, 0); else match_byte_assert (0x58); - get_u32 (); + int n = get_u32(); + if (n >= 0) + { + /* Appears to be the number of references to a footnote. */ + printf (" \n", n); + } + else if (n == -2) + { + /* The user deleted the footnote references. */ + printf (" \n"); + } + else + assert(0); printf ("\n"); } } @@ -747,102 +878,143 @@ dump_fonts(void) match_byte_assert(i); match_byte_assert(0x31); printf(" font=\"%s\"", get_string()); - match_byte_assert(0); - match_byte_assert(0); - if (!match_byte(0x40) && !match_byte(0x20) && !match_byte(0x80) && !match_byte(0x10) && !match_byte(0x70)) - match_byte_assert(0x50); - match_byte_assert(0x41); - if (!match_u32(0) && !match_u32(1)) - match_u32_assert(2); - match_byte_assert(0); - /* OK, this seems really unlikely to be totally correct, but it matches my corpus... */ - if (!match_u32(0) && !match_u32(2)) - { - if (i == 7) - match_u32_assert(0xfaad); - else - match_u32_assert(0); - } + printf(" size=\"%gpt\"", get_float()); + + int style = get_u32(); + if (style & 1) + printf(" bold=\"true\""); + if (style & 2) + printf(" italic=\"true\""); + + bool underline = data[pos++]; + if (underline) + printf(" underline=\"true\""); + + int halign = get_u32(); + printf(" halign=%d", halign); + + int valign = get_u32(); + printf(" valign=%d", valign); - if (!match_u32(0) && !match_u32(1) && !match_u32(2)) - match_u32_assert(3); printf (" fgcolor=\"%s\"", get_string()); printf (" bgcolor=\"%s\"", get_string()); - match_u32_assert(0); - match_u32_assert(0); - match_byte_assert(0); + + if (!match_byte(0)) + match_byte_assert(1); + + char *alt_fgcolor = get_string(); + if (alt_fgcolor[0]) + printf (" altfg=\"%s\"", alt_fgcolor); + char *alt_bgcolor = get_string(); + if (alt_bgcolor[0]) + printf (" altbg=\"%s\"", alt_bgcolor); if (version > 1) { - if (i != 3) + printf(" margins=\""); + for (int i = 0; i < 4; i++) { - if (!match_u32(8)) - match_u32_assert(5); - if (!match_u32(10) && !match_u32(11) && !match_u32(5)) - match_u32_assert(9); - if (!match_u32(0)) - match_u32_assert(1); + if (i) + putchar(' '); + printf("%d", get_u32()); } - else - { - get_u32(); - if (!match_u32(-1) && !match_u32(8)) - match_u32_assert(24); - if (!match_u32(-1) && !match_u32(2)) - match_u32_assert(3); - } - - /* Who knows? Ranges from -1 to 8 with no obvious pattern. */ - get_u32(); + putchar('"'); } printf ("/>\n"); } - match_u32_assert(240); - pos += 240; + int x1 = get_u32(); + int x1_end = pos + x1; + printf("\n"); + match_be32_assert(1); + int n_borders = get_be32(); + for (int i = 0; i < n_borders; i++) + { + int type = get_be32(); + int stroke = get_be32(); + int color = get_be32(); + printf(" \n", + type, + (stroke == 0 ? "none" + : stroke == 1 ? "solid" + : stroke == 2 ? "dashed" + : stroke == 3 ? "thick" + : stroke == 4 ? "thin" + : stroke == 5 ? "double" + : ""), + color); + } + bool grid = get_byte(); + pos += 3; + printf(" \n", grid ? "yes" : "no"); + printf("\n"); + assert(pos == x1_end); - match_u32_assert(18); - pos += 18; + int skip = get_u32(); + assert(skip == 18 || skip == 25); + pos += skip; - if (match_u32(117)) - pos += 117; - else if (match_u32(142)) - pos += 142; - else if (match_u32(143)) - pos += 143; - else if (match_u32(150)) - pos += 150; - else + int x3 = get_u32(); + int x3_end = pos + x3; + if (version == 3) { - match_u32_assert(16); - pos += 16; + match_be32_assert(1); + get_be32(); + printf("\n"); } + pos = x3_end; + /* Manual column widths, if present. */ int count = get_u32(); - pos += 4 * count; + if (count > 0) + { + printf(""); + for (int i = 0; i < count; i++) + { + if (i) + putchar(' '); + printf("%d", get_u32()); + } + printf("\n"); + } - const char *encoding = get_string(); - printf ("%s\n", encoding); + const char *locale = get_string(); + printf ("%s\n", locale); - if (!match_u32(0)) - match_u32_assert(UINT32_MAX); + printf ("%d\n", get_u32()); if (!match_byte(0)) match_byte_assert(1); - match_byte_assert(0); if (!match_byte(0)) match_byte_assert(1); - if (version > 1) - { - if (!match_byte(0x97) && !match_byte(0x98) && !match_byte(0x99)) - match_byte_assert(0x9a); - match_byte_assert(7); - match_byte_assert(0); - match_byte_assert(0); - } - else - match_u32_assert(UINT32_MAX); + if (!match_byte(0)) + match_byte_assert(1); + printf("%d\n", get_u32()); int decimal = data[pos]; int grouping = data[pos + 1]; @@ -854,12 +1026,12 @@ dump_fonts(void) else { match_byte_assert(','); - if (!match_byte('.') && !match_byte(' ')) + if (!match_byte('.') && !match_byte(' ') && !match_byte(',')) match_byte_assert(0); } - printf("\n"); if (match_u32(5)) { @@ -868,170 +1040,284 @@ dump_fonts(void) } else match_u32_assert(0); - int skip = get_u32(); - pos += skip; -} - -int -main(int argc, char *argv[]) -{ - size_t start; - struct stat s; - if (isatty(STDIN_FILENO)) + /* The last chunk is an outer envelope that contains two inner envelopes. + The second inner envelope has some interesting data like the encoding and + the locale. */ + int outer_end = get_end(); + if (version == 3) { - fprintf(stderr, "redirect stdin from a .bin file\n"); - exit(1); - } - if (fstat(STDIN_FILENO, &s)) - { - perror("fstat"); - exit(1); - } - n = s.st_size; - data = malloc(n); - if (!data) - { - perror("malloc"); - exit(1); - } - if (read(STDIN_FILENO, data, n) != n) - { - perror("read"); - exit(1); - } + /* First inner envelope: byte*33 int[n] int*[n]. */ + int inner_len = get_u32(); + int inner_end = pos + inner_len; + int array_start = pos + 33; + match_byte_assert(0); + pos++; /* 0, 1, 10 seen. */ + get_bool(); - if (argc != 2) - { - fprintf (stderr, "usage: %s TYPE < .bin", argv[0]); - exit (1); - } + /* 0=en 1=de 2=es 3=it 5=ko 6=pl 8=zh-tw 10=pt_BR 11=fr */ + printf("lang=%d ", get_byte()); - if (!strcmp(argv[1], "title0")) - { - pos = 0x27; - if (match_byte (0x03) - || (match_byte (0x05) && match_byte (0x58))) - printf ("%s\n", get_string()); - else - printf ("\n"); - return 0; - } - else if (!strcmp(argv[1], "title")) - { - pos = 0x27; - dump_title(); - exit(0); - } - else if (!strcmp(argv[1], "titleraw")) - { - const char fonts[] = "\x01\x31\x09\0\0\0SansSerif"; - start = 0x27; - n = find(fonts, sizeof fonts - 1); - } - else if (!strcmp(argv[1], "fonts")) - { - const char fonts[] = "\x01\x31\x09\0\0\0SansSerif"; - const char styles[] = "\xf0\0\0\0"; - start = find(fonts, sizeof fonts - 1); - n = find(styles, sizeof styles - 1); - } - else if (!strcmp(argv[1], "styles")) - { - const char styles[] = "\xf0\0\0\0"; - const char dimensions[] = "-,,,.\0"; - start = find(styles, sizeof styles - 1); - n = find(dimensions, sizeof dimensions - 1) + sizeof dimensions - 1; - } - else if (!strcmp(argv[1], "dimensions") || !strcmp(argv[1], "all")) - { - pos = 0; - match_byte_assert(1); + printf ("variable_mode=%d\n", get_byte()); + printf ("value_mode=%d\n", get_byte()); + if (!match_u64(0)) + match_u64_assert(UINT64_MAX); + match_u32_assert(0); + match_u32_assert(0); + match_u32_assert(0); + match_u32_assert(0); match_byte_assert(0); + get_bool(); + match_byte_assert(1); + pos = array_start; - /* This might be a version number of some kind, because value 1 seems - to only appear in an SPV file that also required its own weird - special cases in dump_optional_value(). */ - version = get_u32(); - pos -= 4; - if (!match_u32(1)) - match_u32_assert(3); + assert(get_end() == inner_end); + printf(""); + int n_heights = get_u32(); + for (int i = 0; i < n_heights; i++) + { + if (i) + putchar(' '); + printf("%d", get_u32()); + } + printf("\n"); - match_byte_assert(1); - if (!match_byte(0)) - match_byte_assert(1); + int n_style_map = get_u32(); + for (int i = 0; i < n_style_map; i++) + { + uint64_t cell = get_u64(); + int style = get_u16(); + printf("\n", cell, style); + } - /* Offset 8. */ - match_byte_assert(0); - match_byte_assert(0); - if (!match_byte(0)) - match_byte_assert(1); + int n_styles = get_u32(); + for (int i = 0; i < n_styles; i++) + { + printf("\n"); + } - /* Offset 11. */ - pos++; - match_byte_assert(0); - match_byte_assert(0); - match_byte_assert(0); + pos = get_end(); + assert(pos == inner_end); - /* Offset 15. */ - pos++; - if (!match_byte(0)) - match_byte_assert(1); - match_byte_assert(0); - match_byte_assert(0); + /* Second inner envelope. */ + assert(get_end() == outer_end); - /* Offset 19. */ - pos++; - if (!match_byte(0)) - match_byte_assert(1); + match_byte_assert(1); match_byte_assert(0); + if (!match_byte(3) && !match_byte(4)) + match_byte_assert(5); match_byte_assert(0); - - /* Offset 23. */ - pos++; - if (!match_byte(0)) - match_byte_assert(1); match_byte_assert(0); match_byte_assert(0); - /* Offset 27. */ - pos++; - pos++; - match_byte_assert(0); - match_byte_assert(0); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); - /* Offset 31. + get_bool(); + get_bool(); + get_bool(); + get_bool(); - This is the tableId, e.g. -4154297861994971133 would be 0xdca00003. - We don't have enough context to validate it. */ - pos += 4; + printf("%d\n", get_u32()); - /* Offset 35. */ - pos += 4; + if (match_byte('.')) + { + if (!match_byte(',') && !match_byte('\'')) + match_byte_assert(' '); + } + else + { + match_byte_assert(','); + if (!match_byte('.') && !match_byte(' ') && !match_byte(',')) + match_byte_assert(0); + } + + printf ("small: %g\n", get_double()); - dump_title (); - dump_fonts(); - dump_dims (); - dump_data (); - match_byte (1); - if (pos != n) + match_byte_assert(1); + if (outer_end - pos > 6) { - fprintf (stderr, "%x / %x\n", pos, n); - exit(1); + /* There might be a pair of strings representing a dataset and + datafile name, or there might be a set of custom currency strings. + The custom currency strings start with a pair of integers, so we + can distinguish these from a string by checking for a null byte; a + small 32-bit integer will always contain a null and a text string + never will. */ + int save_pos = pos; + int len = get_u32(); + bool has_dataset = !memchr(&data[pos], '\0', len); + pos = save_pos; + + if (has_dataset) + { + printf("%s\n", get_string()); + printf("%s\n", get_string()); + + match_u32_assert(0); + + time_t date = get_u32(); + struct tm tm = *localtime(&date); + char s[128]; + strftime(s, sizeof s, "%a, %d %b %Y %H:%M:%S %z", &tm); + printf("%s\n", s); + + match_u32_assert(0); + } + } + + if (match_u32(5)) + { + for (int i = 0; i < 5; i++) + printf("%s\n", 'A' + i, get_string(), 'A' + i); + } + else + match_u32_assert(0); + + match_byte_assert('.'); + get_bool(); + + if (pos < outer_end) + { + get_u32(); + match_u32_assert(0); } - exit(0); + assert(pos == outer_end); + + pos = outer_end; } - else if (!strcmp(argv[1], "raw")) + else if (outer_end != pos) { - start = 0x27; + pos += 14; + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + printf("%s\n", get_string()); + get_bool(); + match_byte_assert(0); + get_bool(); + get_bool(); - dump_raw(stdout, start, n); + printf("%d\n", get_u32()); + int decimal = data[pos]; + int grouping = data[pos + 1]; + if (match_byte('.')) + { + if (!match_byte(',') && !match_byte('\'')) + match_byte_assert(' '); + } + else + { + match_byte_assert(','); + if (!match_byte('.') && !match_byte(' ') && !match_byte(',')) + match_byte_assert(0); + } + printf("\n"); + if (match_u32(5)) + { + for (int i = 0; i < 5; i++) + printf("%s\n", 'A' + i, get_string(), 'A' + i); + } + else + match_u32_assert(0); + + match_byte_assert('.'); + get_bool(); + + assert(pos == outer_end); + pos = outer_end; } - else +} + +int +main(int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s FILE.bin", argv[0]); + exit (1); + } + + filename = argv[1]; + int fd = open(filename, O_RDONLY); + if (fd < 0) + { + fprintf (stderr, "%s: open failed (%s)", filename, strerror (errno)); + exit (1); + } + + struct stat s; + if (fstat(fd, &s)) + { + perror("fstat"); + exit(1); + } + n = s.st_size; + data = malloc(n); + if (!data) + { + perror("malloc"); + exit(1); + } + if (read(fd, data, n) != n) + { + perror("read"); + exit(1); + } + close(fd); + + pos = 0; + match_byte_assert(1); + match_byte_assert(0); + + version = get_u32(); + assert(version == 1 || version == 3); + + match_byte_assert(1); + bool number_footnotes = get_bool(); + printf("\n", + number_footnotes ? "number" : "letter"); + bool rotate_inner_column_labels = get_bool(); + bool rotate_outer_row_labels = get_bool(); + printf("x=%d\n", get_bool()); + printf("", + rotate_inner_column_labels ? "yes" : "no", + rotate_outer_row_labels ? "yes" : "no"); + //fprintf(stderr, "option-number=%d\n", get_u32()); + get_u32(); + + int min_col_width = get_u32(); + int max_col_width = get_u32(); + int min_row_width = get_u32(); + int max_row_width = get_u32(); + printf("\n", + min_col_width, max_col_width, + min_row_width, max_row_width); + + /* Offset 31. */ + printf("%lld", get_u64()); + + dump_title (); + dump_fonts(); + dump_dims (); + dump_data (); + match_byte (1); + if (pos != n) { - fprintf (stderr, "unknown section %s\n", argv[1]); + fprintf (stderr, "%x / %x\n", pos, n); exit(1); } + exit(0); return 0; }