Updating to new OTS repo from https://github.com/khaledhosny/ots.git

src/ots.h

 // 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.
 
 #ifndef OTS_H_
 #define OTS_H_
 
 #include <stddef.h>
 #include <cstdarg>
 #include <cstddef>
@@ skipping 11 matching lines @@
 
 namespace ots {
 
 #if defined(_MSC_VER) || !defined(OTS_DEBUG)
 #define OTS_FAILURE() false
 #else
 #define OTS_FAILURE() ots::Failure(__FILE__, __LINE__, __PRETTY_FUNCTION__)
 bool Failure(const char *f, int l, const char *fn);
 #endif
 
-#if defined(_MSC_VER)
-// MSVC supports C99 style variadic macros.
-#define OTS_WARNING(format, ...)
+// All OTS_FAILURE_* macros ultimately evaluate to 'false', just like the original
+// message-less OTS_FAILURE(), so that the current parser will return 'false' as
+// its result (indicating a failure).
+
+#if defined(_MSC_VER) || !defined(OTS_DEBUG)
+#define OTS_MESSAGE_(level,otf_,...) \
+  (otf_)->context->Message(level,__VA_ARGS__)
 #else
-// GCC
-#if defined(OTS_DEBUG)
-#define OTS_WARNING(format, args...) \
-    ots::Warning(__FILE__, __LINE__, format, ##args)
-void Warning(const char *f, int l, const char *format, ...)
-     __attribute__((format(printf, 3, 4)));
-#else
-#define OTS_WARNING(format, args...)
-#endif
+#define OTS_MESSAGE_(level,otf_,...) \
+  OTS_FAILURE(), \
+  (otf_)->context->Message(level,__VA_ARGS__)
 #endif
 
-// Define OTS_NO_TRANSCODE_HINTS (i.e., g++ -DOTS_NO_TRANSCODE_HINTS) if you
-// want to omit TrueType hinting instructions and variables in glyf, fpgm, prep,
-// and cvt tables.
-#if defined(OTS_NO_TRANSCODE_HINTS)
-const bool g_transcode_hints = false;
-#else
-const bool g_transcode_hints = true;
-#endif
+// Generate a simple message
+#define OTS_FAILURE_MSG_(otf_,...) \
+  (OTS_MESSAGE_(0,otf_,__VA_ARGS__), false)
+
+#define OTS_WARNING_MSG_(otf_,...) \
+  OTS_MESSAGE_(1,otf_,__VA_ARGS__)
+
+// Generate a message with an associated table tag
+#define OTS_FAILURE_MSG_TAG_(otf_,msg_,tag_) \
+  (OTS_MESSAGE_(0,otf_,"%4.4s: %s", tag_, msg_), false)
+
+// Convenience macros for use in files that only handle a single table tag,
+// defined as TABLE_NAME at the top of the file; the 'file' variable is
+// expected to be the current OpenTypeFile pointer.
+#define OTS_FAILURE_MSG(...) OTS_FAILURE_MSG_(file, TABLE_NAME ": " __VA_ARGS__)
+
+#define OTS_WARNING(...) OTS_WARNING_MSG_(file, TABLE_NAME ": " __VA_ARGS__)
 
 // -----------------------------------------------------------------------------
 // Buffer helper class
 //
 // This class perform some trival buffer operations while checking for
 // out-of-bounds errors. As a family they return false if anything is amiss,
 // updating the current offset otherwise.
 // -----------------------------------------------------------------------------
 class Buffer {
  public:
-  Buffer(const uint8_t *buffer, size_t len)
-      : buffer_(buffer),
+  Buffer(const uint8_t *buf, size_t len)
+      : buffer_(buf),
         length_(len),
         offset_(0) { }
 
   bool Skip(size_t n_bytes) {
     return Read(NULL, n_bytes);
   }
 
-  bool Read(uint8_t *buffer, size_t n_bytes) {
+  bool Read(uint8_t *buf, size_t n_bytes) {
     if (n_bytes > 1024 * 1024 * 1024) {
       return OTS_FAILURE();
     }
     if ((offset_ + n_bytes > length_) ||
         (offset_ > length_ - n_bytes)) {
       return OTS_FAILURE();
     }
-    if (buffer) {
-      std::memcpy(buffer, buffer_ + offset_, n_bytes);
+    if (buf) {
+      std::memcpy(buf, buffer_ + offset_, n_bytes);
     }
     offset_ += n_bytes;
     return true;
   }
 
   inline bool ReadU8(uint8_t *value) {
     if (offset_ + 1 > length_) {
       return OTS_FAILURE();
     }
     *value = buffer_[offset_];
@@ skipping 82 matching lines @@
 template<typename T> T Round2(T value) {
   if (value == std::numeric_limits<T>::max()) {
     return value;
   }
   return (value + 1) & ~1;
 }
 
 bool IsValidVersionTag(uint32_t tag);
 
 #define FOR_EACH_TABLE_TYPE \
-  F(cbdt, CBDT) \
-  F(cblc, CBLC) \
   F(cff, CFF) \
   F(cmap, CMAP) \
   F(cvt, CVT) \
   F(fpgm, FPGM) \
   F(gasp, GASP) \
   F(gdef, GDEF) \
   F(glyf, GLYF) \
   F(gpos, GPOS) \
   F(gsub, GSUB) \
   F(hdmx, HDMX) \
@@ skipping 24 matching lines @@
     FOR_EACH_TABLE_TYPE
 #undef F
   }
 
   uint32_t version;
   uint16_t num_tables;
   uint16_t search_range;
   uint16_t entry_selector;
   uint16_t range_shift;
 
+  OTSContext *context;
+
 #define F(name, capname) OpenType##capname *name;
 FOR_EACH_TABLE_TYPE
 #undef F
 };
 
 #define F(name, capname) \
 bool ots_##name##_parse(OpenTypeFile *f, const uint8_t *d, size_t l); \
 bool ots_##name##_should_serialise(OpenTypeFile *f); \
 bool ots_##name##_serialise(OTSStream *s, OpenTypeFile *f); \
 void ots_##name##_free(OpenTypeFile *f);
 // TODO(yusukes): change these function names to follow Chromium coding rule.
 FOR_EACH_TABLE_TYPE
 #undef F
 
 }  // namespace ots
 
 #endif  // OTS_H_