X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=dump.c;h=04f38e0a751bf41747130472385c1febe6c8c96f;hb=8af10bb39253b97589c5f4b455b708c8fb9e233b;hp=3be7d5a9d6e94391b9adffb1d3cd062bdc4cac91;hpb=b17d33ee847585114dfb2345d8187bcae5b522e9;p=pspp diff --git a/dump.c b/dump.c index 3be7d5a9d6..04f38e0a75 100644 --- a/dump.c +++ b/dump.c @@ -1,3 +1,5 @@ +#include +#include #include #include #include @@ -5,10 +7,13 @@ #include #include #include +#include "u8-mbtouc.h" static uint8_t *data; static size_t n; +int version; + static bool all_ascii(const uint8_t *p, size_t n) { @@ -25,13 +30,6 @@ try_find(const char *target, size_t target_len) return pos ? pos - data : 0; } -static size_t -try_find_tail(const char *target, size_t target_len) -{ - size_t pos = try_find(target, target_len); - return pos ? pos + target_len : 0; -} - static size_t find(const char *target, size_t target_len) { @@ -44,18 +42,6 @@ find(const char *target, size_t target_len) return pos; } -static size_t -find_tail(const char *target, size_t target_len) -{ - size_t pos = try_find_tail(target, target_len); - if (!pos) - { - fprintf (stderr, "not found\n"); - exit(1); - } - return pos; -} - size_t pos; #define XSTR(x) #x @@ -124,6 +110,91 @@ 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) +{ + 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++; + } + } + + +} + +static bool __attribute__((unused)) +all_utf8(const char *p_) +{ + const uint8_t *p = (const uint8_t *) p_; + size_t len = strlen ((char *) p); + for (size_t ofs = 0, mblen; ofs < len; ofs += mblen) + { + ucs4_t uc; + + mblen = u8_mbtouc (&uc, p + ofs, len - ofs); + if ((uc < 32 && uc != '\n') || uc == 127 || uc == 0xfffd) + return false; + } + return true; +} + static char * get_string(const char *where) { @@ -147,96 +218,237 @@ get_string(const char *where) } #define get_string() get_string(WHERE) +static int +get_end(void) +{ + int len = get_u32(); + return pos + len; +} + +static char * +dump_counted_string(void) +{ + char *s = NULL; + int inner_end = get_end(); + if (pos != inner_end) + { + match_u32_assert(0); + 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 char * +dump_nested_string(void) +{ + char *s = NULL; + + match_byte_assert (0); + match_byte_assert (0); + int outer_end = get_end(); + s = dump_counted_string(); + match_byte_assert(0x58); + match_byte_assert(0x58); + if (pos != outer_end) + { + fprintf(stderr, "outer end discrepancy\n"); + exit(1); + } + + return s; +} + static void -dump_value_31(void) +dump_optional_value(FILE *stream) { if (match_byte (0x31)) { if (match_u32 (0)) { if (match_u32 (1)) - get_string(); + { + /* Corpus frequencies: + 124 "a" + 12 "b" + 8 "a, b" + */ + get_string(); + } else match_u32_assert (0); - int subn = get_u32 (); - printf ("nested %d bytes", subn); - pos += subn; + + if (version == 1) + { + /* We only have one SPV file for this version (with many + tables). */ + match_byte(0); + if (!match_u32(1)) + match_u32_assert(2); + match_byte(0); + match_byte(0); + if (!match_u32(0) && !match_u32(1) && !match_u32(2) && !match_u32(3) && !match_u32(4) && !match_u32(5) && !match_u32(6) && !match_u32(7) && !match_u32(8) && !match_u32(9)) + match_u32_assert(10); + match_byte(0); + match_byte(0); + return; + } + + int outer_end = get_end(); + + /* This counted-string appears to be a template string, + e.g. "Design\: [:^1:]1 Within Subjects Design\: [:^1:]2". */ + dump_counted_string(); + + 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); + if (pos != outer_end) + { + fprintf(stderr, "outer end discrepancy\n"); + exit(1); + } } else if (match_u32 (1)) { - printf("(footnote %d) ", get_u32()); - match_byte_assert (0); - match_byte_assert (0); - int subn = get_u32 (); - printf ("nested %d bytes", subn); - pos += subn; + fprintf(stream, "(footnote %d) ", get_u32()); + dump_nested_string(); } else if (match_u32 (2)) { - printf("(special 2)"); - match_byte_assert(0); - match_byte_assert(0); - if (!match_u32 (2)) - match_u32_assert(1); - match_byte_assert(0); + fprintf(stream, "(special 2)"); + if (!match_byte(0)) + match_byte_assert(2); match_byte_assert(0); - int subn = get_u32 (); - printf ("nested %d bytes", subn); - pos += subn; + if (!match_u32 (2) && !match_u32(1)) + match_u32_assert(3); + dump_nested_string(); } else { match_u32_assert(3); - printf("(special 3)"); + fprintf(stream, "(special 3)"); match_byte_assert(0); match_byte_assert(0); match_byte_assert(1); match_byte_assert(0); - int subn = get_u32 (); - printf ("nested %d bytes, ", subn); - pos += subn; - subn = get_u32 (); - printf ("nested %d bytes, ", subn); - pos += subn; + match_u32_assert(2); + dump_nested_string(); /* Our corpus doesn't contain any examples with strings though. */ } } else match_byte_assert (0x58); } -static void -dump_value__(int level, bool match1) +static const char * +format_to_string (int type) { - for (int i = 0; i <= level; i++) - printf (" "); + static char tmp[16]; + switch (type) + { + case 1: return "A"; + case 2: return "AHEX"; + case 3: return "COMMA"; + case 4: return "DOLLAR"; + case 5: case 40: return "F"; + case 6: return "IB"; + case 7: return "PIBHEX"; + case 8: return "P"; + case 9: return "PIB"; + case 10: return "PK"; + case 11: return "RB"; + case 12: return "RBHEX"; + case 15: return "Z"; + case 16: return "N"; + case 17: return "E"; + case 20: return "DATE"; + case 21: return "TIME"; + case 22: return "DATETIME"; + case 23: return "ADATE"; + case 24: return "JDATE"; + case 25: return "DTIME"; + case 26: return "WKDAY"; + case 27: return "MONTH"; + case 28: return "MOYR"; + case 29: return "QYR"; + case 30: return "WKYR"; + case 31: return "PCT"; + case 32: return "DOT"; + case 33: return "CCA"; + case 34: return "CCB"; + case 35: return "CCC"; + case 36: return "CCD"; + case 37: return "CCE"; + case 38: return "EDATE"; + case 39: return "SDATE"; + default: + abort(); + sprintf(tmp, "<%d>", type); + return tmp; + } +} +static void +dump_value(FILE *stream, int level) +{ match_byte(0); match_byte(0); match_byte(0); match_byte(0); - if (match_byte (3)) - { - char *s1 = get_string(); - dump_value_31(); - char *s2 = get_string(); - char *s3 = get_string(); - if (strcmp(s1, s3)) - printf("strings \"%s\", \"%s\" and \"%s\"", s1, s2, s3); - else - printf("string \"%s\" and \"%s\"", s1, s2); - if (!match_byte (0)) - match_byte_assert(1); - if (match1) - match_byte (1); - } - else if (match_byte (5)) + for (int i = 0; i <= level; i++) + fprintf (stream, " "); + + if (match_byte (1)) { - dump_value_31(); - printf ("variable \"%s\"", get_string()); - get_string(); - if (!match_byte(1) && !match_byte(2)) - match_byte_assert(3); + 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); } else if (match_byte (2)) { @@ -244,50 +456,75 @@ dump_value__(int level, bool match1) char *var, *vallab; double value; - match_byte_assert (0x58); + dump_optional_value (stream); format = get_u32 (); value = get_double (); var = get_string (); vallab = get_string (); - printf ("value %g format %d(%d.%d) var \"%s\" vallab \"%s\"", - value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab); + fprintf (stream, "> 16), (format >> 8) & 0xff, format & 0xff); + if (var[0]) + fprintf (stream, " variable=\"%s\"", var); + if (vallab[0]) + fprintf (stream, " label=\"%s\"/>\n", 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_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 (4)) { unsigned int format; char *var, *vallab, *value; - match_byte_assert (0x58); + dump_optional_value(stream); format = get_u32 (); vallab = get_string (); var = get_string (); if (!match_byte(1) && !match_byte(2)) match_byte_assert (3); value = get_string (); - printf ("value \"%s\" format %d(%d.%d) var \"%s\" vallab \"%s\"", - value, format >> 16, (format >> 8) & 0xff, format & 0xff, var, vallab); + fprintf (stream, "> 16), (format >> 8) & 0xff, format & 0xff); + if (var[0]) + fprintf (stream, " variable=\"%s\"", var); + if (vallab[0]) + 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_value_31(); - format = get_u32 (); - value = get_double (); - printf ("value %g format %d(%d.%d)", value, format >> 16, (format >> 8) & 0xff, format & 0xff); - if (match1) - match_byte (1); + 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); } else { - dump_value_31(); + dump_optional_value(stream); char *base = get_string(); int x = get_u32(); - printf ("\"%s\" with %d variables:\n", base, x); + fprintf (stream, "\n"); } } +static int +compare_int(const void *a_, const void *b_) +{ + const int *a = a_; + const int *b = b_; + return *a < *b ? -1 : *a > *b; +} + static void -dump_category(int level) +check_permutation(int *a, int n, const char *name) { - dump_value__ (level, true); - match_byte(0); - match_byte(0); - match_byte(0); + int b[n]; + memcpy(b, a, n * sizeof *a); + qsort(b, n, sizeof *b, compare_int); + for (int i = 0; i < n; i++) + if (b[i] != i) + { + fprintf(stderr, "bad %s permutation:", name); + for (int i = 0; i < n; i++) + fprintf(stderr, " %d", a[i]); + putc('\n', stderr); + exit(1); + } +} + +static void +dump_category(FILE *stream, int level, int *indexes, int *n_indexes, int max_indexes) +{ + for (int i = 0; i <= level; i++) + fprintf (stream, " "); + printf ("\n"); + dump_value (stream, level + 1); - if (match_u32 (1)) - match_byte (0); - else if (match_byte (1)) + int merge = data[pos]; + if (!match_byte(0)) + match_byte_assert (1); + + match_byte_assert (0); + + int unindexed = data[pos]; + if (!match_byte(0)) + match_byte_assert (1); + + 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) { - match_byte (0); - if (!match_u32 (2)) - match_u32_assert (1); - match_byte (0); + if (merge) + { + for (int i = 0; i <= level + 1; i++) + fprintf (stream, " "); + fprintf (stream, "\n"); + } + } + else + { + if (merge) + { + fprintf(stderr, "index not -1 but merged\n"); + exit(1); + } + if (x != 2) + { + fprintf(stderr, "index not -1 but x != 2\n"); + exit(1); + } + if (n_categories != 0) + { + fprintf(stderr, "index not -1 but subcategories\n"); + exit(1); + } + if (*n_indexes >= max_indexes) + { + fprintf(stderr, "too many categories (increase max_indexes)\n"); + exit(1); + } + indexes[(*n_indexes)++] = indx; } - else if (!match_u32(2)) - match_u32_assert (0); - get_u32 (); + int expected_unindexed = indx == -1; + if (unindexed != expected_unindexed) + { + fprintf(stderr, "unindexed (%d) mismatch with indx (%d)\n", + unindexed, indx); + exit(1); + } - int n_categories = get_u32(); - if (n_categories > 0) - printf (", %d subcategories:", n_categories); - printf("\n"); + if (n_categories == 0) + { + for (int i = 0; i <= level + 1; i++) + fprintf (stream, " "); + fprintf (stream, "%d\n", indx); + } for (int i = 0; i < n_categories; i++) - dump_category (level + 1); + dump_category (stream, level + 1, indexes, n_indexes, max_indexes); + for (int i = 0; i <= level; i++) + fprintf (stream, " "); + printf ("\n"); } -static void -dump_dim(void) +static int +dump_dim(int indx) { int n_categories; - printf("next dim\n"); - dump_value__ (0, false); - /* This byte is usually 0x02 but 0x00 and 0x75 (!) have also been spotted. */ + printf ("\n", indx); + dump_value (stdout, 0); + + /* This byte is usually 0 but many other values have been spotted. */ pos++; if (!match_byte(0) && !match_byte(1)) @@ -353,160 +669,208 @@ dump_dim(void) match_u32_assert(2); if (!match_byte(0)) match_byte_assert(1); - get_u32(); - match_byte(0); - match_byte(0); + if (!match_byte(0)) + match_byte_assert(1); + match_byte_assert(1); + if (!match_u32(UINT32_MAX)) + match_u32_assert(indx); n_categories = get_u32(); - printf("%d nested categories\n", n_categories); + + int indexes[2048]; + int n_indexes = 0; for (int i = 0; i < n_categories; i++) - dump_category (0); + dump_category (stdout, 0, indexes, &n_indexes, sizeof indexes / sizeof *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(); - printf ("%u dimensions\n", n_dims); + assert(n_dims < MAX_DIMS); for (int i = 0; i < n_dims; i++) - { - printf("\n"); - dump_dim (); - } -} - -static int -compare_int(const void *a_, const void *b_) -{ - const int *a = a_; - const int *b = b_; - return *a < *b ? -1 : *a > *b; + 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], b[n_dims]; - for (int i = 0; i < n_dims; i++) - a[i] = b[i] = get_u32(); - qsort(b, n_dims, sizeof *b, compare_int); + int a[n_dims]; for (int i = 0; i < n_dims; i++) - if (b[i] != i) - { - fprintf(stderr, "bad dimension permutation:"); - for (int i = 0; i < n_dims; i++) - fprintf(stderr, " %d", a[i]); - putc('\n', stderr); - exit(1); - } + { + 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 ("%d data values, starting at %08x\n", x, pos); + printf ("\n"); for (int i = 0; i < x; i++) { - printf("%08x, index %d:\n", pos, get_u32()); + unsigned int indx = get_u32(); + printf (" \n"); match_u32_assert(0); - dump_value__(0, false); - putchar('\n'); + if (version == 1) + match_byte(0); + dump_value(stdout, 1); + fprintf (stdout, " \n"); } + printf ("\n"); } static void dump_title(void) { - pos = 0x27; - dump_value__(0, true); putchar('\n'); - dump_value__(0, true); putchar('\n'); + printf ("\n"); + dump_value(stdout, 0); + match_byte(1); + printf ("\n"); + + printf ("\n"); + dump_value(stdout, 0); + match_byte(1); + printf ("\n"); + match_byte_assert(0x31); - dump_value__(0, true); putchar('\n'); + + printf ("\n"); + dump_value(stdout, 0); + match_byte(1); + printf ("\n"); + match_byte(0); match_byte_assert(0x58); if (match_byte(0x31)) { - dump_value__(0, false); putchar('\n'); + printf ("\n"); + dump_value(stdout, 0); + printf ("\n"); } else match_byte_assert(0x58); - int n_footnotes = get_u32(); - if (n_footnotes >= 20) + for (int i = 0; i < n_footnotes; i++) { - fprintf(stderr, "%08x: %d footnotes\n", pos - 4, n_footnotes); - exit(1); - } - - printf("------\n%d footnotes\n", n_footnotes); - if (n_footnotes < 20) - { - for (int i = 0; i < n_footnotes; i++) - { - printf("footnote %d:\n", i); - dump_value__(0, false); - if (match_byte (0x31)) - { - /* Custom footnote marker string. */ - match_byte_assert(3); - get_string(); - match_byte_assert(0x58); - match_u32_assert(0); - get_string(); - } - else - match_byte_assert (0x58); - printf("(%d)\n", get_u32()); - } + printf ("\n", i); + dump_value(stdout, 0); + /* Custom footnote marker string. */ + if (match_byte (0x31)) + dump_value(stdout, 0); + else + match_byte_assert (0x58); + get_u32 (); + printf ("\n"); } } -static int -find_dimensions(void) +static void __attribute__((unused)) +hex_dump(int ofs, int n) { - { - const char dimensions[] = "-,,,.\0"; - int x = try_find_tail(dimensions, sizeof dimensions - 1); - if (x) - return x; - } - - const char dimensions[] = "-,,, .\0"; - return find_tail(dimensions, sizeof dimensions - 1); + for (int i = 0; i < n; i++) + { + int c = data[ofs + i]; +#if 0 + if (i && !(i % 16)) + fprintf(stderr, "-"); + else + fprintf(stderr, " "); +#endif + fprintf(stderr, "%02x ", c); + //fprintf(stderr, "%c", c >= 32 && c < 127 ? c : '.'); + } + fprintf(stderr, "\n"); } static void dump_fonts(void) { - printf("fonts: offset=%08x\n", pos); match_byte(0); for (int i = 1; i <= 8; i++) { - printf("%08x: font %d, ", pos, i); + printf ("