X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=dump-spo2.c;h=971fbab8eacf1b3390c5c51d6709d45b531396ee;hb=01a71e5995ba958ed1c72997c227d589235de6fe;hp=58dbf0539ddb370535ca1c3af431cecde0099cee;hpb=0ee5ac77918b105dd6a5f8469947b9f040bd2bfa;p=pspp

diff --git a/dump-spo2.c b/dump-spo2.c
index 58dbf0539d..971fbab8ea 100644
--- a/dump-spo2.c
+++ b/dump-spo2.c
@@ -125,7 +125,8 @@ match_u16_assert(uint16_t x, const char *where)
   unsigned int y = get_u16();
   if (x != y)
     {
-      fprintf(stderr, "%s: 0x%x: expected u16:%u, got u16:%u\n", where, pos - 2, x, y);
+      fprintf(stderr, "%s: 0x%x: expected u16:%u, got u16:%u: ", where, pos - 2, x, y);
+      hex_dump(stderr, pos - 2, 64);
       exit(1);
     }
 }
@@ -255,33 +256,43 @@ all_utf8(const char *p_, size_t len)
 }
 
 static char *
-get_string2(void)
+pull_string(int len, const char *where)
 {
-  int len = data[pos] + data[pos + 1] * 256;
-  char *s = xmemdup0(&data[pos + 2], len);
-  pos += 2 + len;
+  assert (len >= 0);
+  for (int i = 0; i < len - 1; i++)
+    if (!data[pos + i])
+      {
+        fprintf(stderr, "%s: %d-byte string starting at 0x%x has null byte "
+                "at offset %d: ", where, len, pos, i);
+        hex_dump(stderr, pos, len + 64);
+        exit(1);
+      }
+
+  char *s = xmemdup0(&data[pos], len);
+  pos += len;
   return s;
 }
 
 static char *
-get_string1(void)
+get_string2(const char *where)
+{
+  return pull_string(get_u16(), where);
+}
+#define get_string2() get_string2(WHERE)
+
+static char *
+get_string1(const char *where)
 {
   int len = data[pos++];
-  if (len == 0xff)
-    return get_string2();
-  else
-    {
-      char *s = xmemdup0(&data[pos], len);
-      pos += len;
-      return s;
-    }
+  return len == 0xff ? (get_string2)(where) : pull_string(len, where);
 }
+#define get_string1() get_string1(WHERE)
 
 static void
 match_string1_assert(const char *exp, const char *where)
 {
   int start = pos;
-  char *act = get_string1();
+  char *act = (get_string1)(where);
   if (strcmp(act, exp)) 
     {
       fprintf(stderr, "%s: 0x%x: expected \"%s\", got \"%s\"\n",
@@ -295,7 +306,7 @@ static void
 match_string2_assert(const char *exp, const char *where)
 {
   int start = pos;
-  char *act = get_string2();
+  char *act = (get_string2)(where);
   if (strcmp(act, exp)) 
     {
       fprintf(stderr, "%s: 0x%x: expected \"%s\", got \"%s\"\n",
@@ -308,24 +319,8 @@ match_string2_assert(const char *exp, const char *where)
 static char *
 get_string4(const char *where)
 {
-  if (1
-      /*data[pos + 1] == 0 && data[pos + 2] == 0 && data[pos + 3] == 0*/
-      /*&& all_ascii(&data[pos + 4], data[pos])*/)
-    {
-      assert(data[pos + 3] == 0);
-      int len = data[pos] + data[pos + 1] * 256 + data[pos + 2] * 65536;
-      char *s = malloc(len + 1);
-
-      memcpy(s, &data[pos + 4], len);
-      s[len] = 0;
-      pos += 4 + len;
-      return s;
-    }
-  else
-    {
-      fprintf(stderr, "%s: 0x%x: expected string\n", where, pos);
-      exit(1);
-    }
+  assert(data[pos + 3] == 0);
+  return pull_string(get_u32(), where);
 }
 #define get_string4() get_string4(WHERE)
 
@@ -837,13 +832,63 @@ parse_IndexedCollection(void)
     }
 }
 
+static void
+parse_PTTableLook(void)
+{
+  match_byte_assert(2);
+  match_byte_assert(2);
+  match_zeros_assert(7);
+  match_u32_assert(0x36);
+  match_u32_assert(0x12);
+}
+
+static void
+parse_PVViewDimension(void)
+{
+  while (data[pos + 1] != 0x80
+         && (data[pos] != 0xff || data[pos + 1] != 0xff))
+    {
+      assert(pos < n);
+      pos++;
+    }
+}
+
+static void
+parse_PVSeparatorStyle(void)
+{
+  match_byte_assert(0);
+  match_byte_assert(1);
+  match_zeros_assert(15);
+  pos++;
+  match_byte_assert(0x80);
+  match_byte_assert(0);
+
+  match_byte_assert(1);
+  match_zeros_assert(9);
+  while (data[pos + 1] != 0x80
+         && (data[pos] != 0xff || data[pos + 1] != 0xff))
+    {
+      assert(pos < n);
+      pos++;
+    }
+}
+
+static void
+parse_PVCellStyle(void)
+{
+  match_byte_assert(0);
+  match_byte_assert(1);
+  match_zeros_assert(5);
+  match_u32_assert(0xffffff);
+  match_zeros_assert(2);
+}
+
 static void
 parse_flexible(void)
 {
   int start = pos;
-  if (data[pos] == 0xff && data[pos + 1] == 0xff)
+  if (match_u16(0xffff))
     {
-      match_u16_assert(0xffff);
       match_u16_assert(0);
       char *heading = get_string2();
       if (!strcmp(heading, "DspCell"))
@@ -870,10 +915,24 @@ parse_flexible(void)
         match_byte_assert(3);
       else if (!strcmp(heading, "NDimensional__DspCell"))
         parse_NDimensional__DspCell();
+      else if (!strcmp(heading, "PMPivotItemTree"))
+        match_byte_assert(0);
+      else if (!strcmp(heading, "PMModelItemInfo"))
+        parse_PMModelItemInfo();
+      else if (!strcmp(heading, "AbstractTreeBranch"))
+        match_byte_assert(0);
+      else if (!strcmp(heading, "PTTableLook"))
+        parse_PTTableLook();
+      else if (!strcmp(heading, "PVViewDimension"))
+        parse_PVViewDimension();
+      else if (!strcmp(heading, "PVSeparatorStyle"))
+        parse_PVSeparatorStyle();
+      else if (!strcmp(heading, "PVCellStyle"))
+        parse_PVCellStyle();
       else
         {
           fprintf(stderr, "don't know %s at offset 0x%x: ", heading, start);
-          hex_dump(stderr, pos, 64);
+          hex_dump(stderr, pos, 128);
           assert(0);
         }
     }
@@ -908,9 +967,29 @@ parse_flexible(void)
             {
               printf ("15 80(%f", get_double());
               printf (" %s)\n", get_string1());
+              if (match_byte(1))
+                {
+                  match_byte_assert(0);
+                  get_string1();
+                  if (!match_byte(2) && !match_byte(3))
+                    match_byte_assert(0);
+                  match_zeros_assert(3);
+                  get_string1();
+                  match_byte_assert(0);
+                  match_byte_assert(1);
+                  match_zeros_assert(3);
+                  match_byte_assert(1);
+                  match_byte_assert(0);
+                }
             }
           else
-            match_zeros_assert(14);
+            {
+              match_byte_assert(0);
+              if (match_u32(0xc))
+                match_u16_assert(1);
+              else
+                match_zeros_assert(13);
+            }
         }
       else if (data[pos] == 0x9 && data[pos + 1] == 0x80)
         {
@@ -921,28 +1000,214 @@ parse_flexible(void)
       else if (data[pos] == 0x11 || data[pos] == 0x13)
         {
           pos += 2;
-          match_zeros_assert(14);
+          match_byte_assert(0);
+          if (match_u32(0xc) || match_u32(0xd))
+            match_u16_assert(1);
+          else
+            match_zeros_assert(13);
+        }
+      else if (data[pos] == 0x29 ||
+               data[pos] == 0x2b ||
+               data[pos] == 0x2d ||
+               data[pos] == 0x31 ||
+               data[pos] == 0x32 ||
+               data[pos] == 0x4a ||
+               data[pos] == 0x4c ||
+               data[pos] == 0x4f ||
+               data[pos] == 0x4d ||
+               data[pos] == 0x50 ||
+               data[pos] == 0x36 ||
+               data[pos] == 0x52 ||
+               data[pos] == 0x53 ||
+               data[pos] == 0x54 ||
+               data[pos] == 0x55 ||
+               data[pos] == 0x57 ||
+               data[pos] == 0x56 ||
+               data[pos] == 0x58 ||
+               data[pos] == 0x5c ||
+               data[pos] == 0x5b ||
+               data[pos] == 0x5e ||
+               data[pos] == 0x62 ||
+               data[pos] == 0x64 ||
+               data[pos] == 0x4e ||
+               data[pos] == 0x51 ||
+               data[pos] == 0x59 ||
+               data[pos] == 0x5a ||
+               data[pos] == 0x5d ||
+               data[pos] == 0x66 ||
+               data[pos] == 0x60 ||
+               data[pos] == 0x68 ||
+               data[pos] == 0x48 ||
+               data[pos] == 0x6a ||
+               data[pos] == 0x37)
+        {
+          pos += 2;
+          match_byte_assert(0);
+        }
+      else if (data[pos] == 0x2c ||
+               data[pos] == 0x2e ||
+               data[pos] == 0x30 ||
+               data[pos] == 0x34 ||
+               data[pos] == 0x3d ||
+               data[pos] == 0x40 ||
+               data[pos] == 0x3f ||
+               data[pos] == 0x42 ||
+               data[pos] == 0x43 ||
+               data[pos] == 0x44 ||
+               data[pos] == 0x49 ||
+               data[pos] == 0x3e ||
+               data[pos] == 0x46)
+        {
+          pos += 2;
+          parse_format();
         }
       else
         {
+#if 0
           fprintf (stderr, "bad record 0x%02x at offset %x: ",
                    data[pos], pos);
+#endif
           hex_dump (stderr, pos, 64);
           assert(0);
         }
     }
   else if (match_byte(0xa)) 
     {
-      match_zeros_assert(5);
-      assert(pos == n);
-      exit (0);
+      if (!match_byte(7))
+        match_byte_assert(0);
+      if (match_u16(0x0e74))
+        match_byte_assert(0);
+      else
+        {
+          match_zeros_assert(4);
+          if (pos == n)
+            exit (0);
+          match_zeros_assert (2);
+        }
+    }
+#if 0
+  else if (match_byte(1))
+    {
+      match_byte_assert(0);
+      get_string1();
+      if (!match_byte(2))
+        match_byte_assert(0);
+      if (match_byte(0))
+        {
+          match_zeros_assert(2);
+          get_string1();
+          if (match_byte(0x08))
+            {
+              match_byte_assert(0);
+              match_u16_assert(0x0e74);
+              match_byte_assert(0);
+            }
+          else if (match_byte(3))
+            {
+              match_byte_assert(0);
+              if (match_u16(0x0e74))
+                match_byte_assert(0);
+              else
+                {
+                  match_zeros_assert(6);
+                  if (!match_byte(0xe) && !match_byte(0x11))
+                    match_byte_assert(0);
+                  match_byte_assert(0);
+                  if (!match_u16(0x0e74))
+                    match_u16_assert(0);
+                  match_byte_assert(0);
+                }
+            }
+          else
+            {
+              match_byte_assert(0);
+              match_byte_assert(1);
+              match_zeros_assert(3);
+              match_byte_assert(1);
+              match_byte_assert(0);
+            }
+        }
+    }
+#endif
+  else //if (match_u16(2) || match_u16(3) || match_u16(4) || match_u16(5) || match_u16(6) || match_u16(7) || match_u16(8) || match_u16(9))
+    {
+      while (data[pos + 1] != 0x80
+             && (data[pos] != 0xff || data[pos + 1] != 0xff))
+        {
+          assert(pos < n);
+          pos++;
+        }
+    }
+#if 0
+  else if (match_byte(7) || match_byte(4) || match_byte(5) || match_byte(6) || match_byte(8) || match_byte(9) || match_byte(0xb) || match_byte(0xc) || match_byte(0x15) || match_byte(0x16) || match_byte(0x17) || match_byte(0x18) || match_byte(0x1e)  || match_byte(0x1a))
+    {
+      if (!match_byte(7))
+        match_byte_assert(0);
+      if (!match_u16(0x0e74))
+        match_byte_assert(0);
+      match_byte_assert(0);
+    }
+  else if (match_byte(2) || match_byte(3))
+    {
+      match_byte_assert(0);
+      if (!match_u16(0x0e74))
+        {
+          match_zeros_assert(2);
+          if (match_byte(0))
+            {
+              match_zeros_assert(3);
+              if (match_byte(0))
+                match_zeros_assert(4);
+              else
+                {
+                  pos++;
+                  match_byte(0);
+                  match_u16_assert(0x0e74);
+                }
+            }
+        }
+      //match_byte_assert(0);
+    }
+  else if (match_byte(0xd) || match_byte(0xe) || match_byte(0xf)
+           || match_byte(0x11) || match_byte(0x12) || match_byte(0x13)
+           || match_byte(0x14) || match_byte(0x1b))
+    {
+      if (!match_byte(0x07))
+        match_byte_assert(0);
+      if (!match_u16(0x0e74))
+        match_zeros_assert(11);
+      else
+        match_byte_assert(0);
     }
+  else if (match_byte(0xe3) || match_byte(0xdb) || match_byte(0xd8) || match_byte(0xe9) || match_byte(0xf3))
+    {
+      match_byte_assert(0x0e);
+      match_byte_assert(0x74);
+      match_byte_assert(0x0e);
+      match_byte_assert(0);
+    }
+  else if (match_byte(0x9d) || match_byte(0x9e) || match_byte(0x9c))
+    match_u32_assert(0x000e741a);
+  else if (match_byte(0x10))
+    {
+      match_byte_assert(0);
+      if (match_byte(0))
+        match_zeros_assert(10);
+      else
+        {
+          match_u16_assert(0x0e74);
+          match_byte_assert(0);
+        }
+    }
+  else if (match_byte(0x39) || match_byte(0x3a) || match_byte(0x3b))
+    match_u32_assert(0x000e7409);
   else
     {
-      fprintf (stderr, "bad record start at offset %x: ", pos);
+      //fprintf (stderr, "bad record start at offset %x: ", pos);
       hex_dump (stderr, pos, 64);
       assert(0);
     }
+#endif
 }
 
 
@@ -1075,23 +1340,13 @@ main(int argc, char *argv[])
     exit(0);
   parse_heading("NavLog");
   parse_NavLog();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
-  parse_flexible();
+  for (;;)
+    {
+      if (data[pos] == 0)
+        pos++;
+      else
+        parse_flexible();
+    }
   exit(0);
   puts(get_padded_string(32));
   if (!match_u32(80))