Revive Tag() function

src/ots.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ots.h"
 
 #include <sys/types.h>
 #include <zlib.h>
 
 #include <algorithm>
@@ skipping 65 matching lines @@
     hunks_.push_back(p);
     return p;
   }
 
  private:
   std::vector<uint8_t*> hunks_;
 };
 
 // Use a macro instead of a function because gcc 4.4.3 creates static
 // initializers in that case.
-#if defined(__BIG_ENDIAN__) || defined(_BIG_ENDIAN)
-#define TAG(d, c, b, a) (a | (b << 8) | (c << 16) | (d << 24))
-#else
-#define TAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24))
+// Try endianness checks with zero, one and two leading underscores,

[Yusuke Sato, 2012/05/01 02:23:31]

The #ifdefs look too complex to me. What about reviving Tag() and then using the
following simple solution?

const struct {
  const char* tag;
...
} table_parsers[] = {
  { "maxp", ...

...

if (Tag(table_parsers[i].tag) == Tag("head")) {

[bashi, 2012/05/01 04:05:49]

Done. Thank you for suggestion!

+// as the symbols actually defined seem to vary between systems. (Sigh.)
+#if defined(BIG_ENDIAN) && defined(LITTLE_ENDIAN) && defined(BYTE_ORDER)
+#  if BYTE_ORDER == BIG_ENDIAN
+#    define TAG(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
+#  elif BYTE_ORDER == LITTLE_ENDIAN
+#    define TAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24))
+#  else
+#    error "unsupported byte order!"
+#  endif
+#elif defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN) && defined(_BYTE_ORDER)
+#  if _BYTE_ORDER == _BIG_ENDIAN
+#    define TAG(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
+#  elif _BYTE_ORDER == _LITTLE_ENDIAN
+#    define TAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24))
+#  else
+#    error "unsupported byte order!"
+#  endif
+#elif defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN) && defined(__BYTE_ORDER)
+#  if __BYTE_ORDER == __BIG_ENDIAN
+#    define TAG(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
+#  elif __BYTE_ORDER == __LITTLE_ENDIAN
+#    define TAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24))
+#  else
+#    error "unsupported byte order!"
+#  endif
+#elif defined(__BIG_ENDIAN__)
+#  define TAG(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
+#else // fall back to assuming little-endian
+#  define TAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24))
 #endif
 
 const struct {
   uint32_t tag;
   bool (*parse)(ots::OpenTypeFile *otf, const uint8_t *data, size_t length);
   bool (*serialise)(ots::OTSStream *out, ots::OpenTypeFile *file);
   bool (*should_serialise)(ots::OpenTypeFile *file);
   void (*free)(ots::OpenTypeFile *file);
   bool required;
 } table_parsers[] = {
@@ skipping 615 matching lines @@
     va_start(va, format);
     std::vfprintf(stderr, format, va);
     va_end(va);
     std::fprintf(stderr, "\n");
     std::fflush(stderr);
   }
 }
 #endif
 
 }  // namespace ots