Merge branch 'master' of https://github.com/google/flatbuffers into fuzzer2

include/flatbuffers/code_generators.h

@@ -21,17 +21,70 @@ namespace flatbuffers {
 
 class BaseGenerator {
  public:
-  BaseGenerator(const Parser &parser, const std::string &path,
-                const std::string &file_name)
-      : parser_(parser), path_(path), file_name_(file_name){};
   virtual bool generate() = 0;
 
+  static const std::string NamespaceDir(const Parser &parser,
+                                        const std::string &path) {
+    EnsureDirExists(path.c_str());
+    if (parser.opts.one_file) return path;
+    std::string namespace_dir = path;  // Either empty or ends in separator.
+    auto &namespaces = parser.namespaces_.back()->components;
+    for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
+      namespace_dir += *it + kPathSeparator;
+      EnsureDirExists(namespace_dir.c_str());
+    }
+    return namespace_dir;
+  }
+
  protected:
+  BaseGenerator(const Parser &parser, const std::string &path,
+                const std::string &file_name)
+      : parser_(parser),
+        path_(path),
+        file_name_(file_name),
+        namespace_dir_(BaseGenerator::NamespaceDir(parser, path)){};
   virtual ~BaseGenerator(){};
 
+  // No copy/assign.
+  BaseGenerator &operator=(const BaseGenerator &);
+  BaseGenerator(const BaseGenerator &);
+
+  const char *FlatBuffersGeneratedWarning() {
+    return "automatically generated by the FlatBuffers compiler,"
+           " do not modify\n\n";
+  }
+
+  bool IsEverythingGenerated() {
+    for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
+         ++it) {
+      if (!(*it)->generated) return false;
+    }
+    for (auto it = parser_.structs_.vec.begin();
+         it != parser_.structs_.vec.end(); ++it) {
+      if (!(*it)->generated) return false;
+    }
+    return true;
+  }
+
+  std::string FullNamespace(const char *separator) {
+    std::string namespace_name;
+    auto &namespaces = parser_.namespaces_.back()->components;
+    for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
+      if (namespace_name.length()) namespace_name += separator;
+      namespace_name += *it;
+    }
+    return namespace_name;
+  }
+
+  const std::string LastNamespacePart() {
+    auto &namespaces = parser_.namespaces_.back()->components;
+    if (namespaces.size()) return *(namespaces.end() - 1); else return std::string("");
+  }
+
   const Parser &parser_;
   const std::string &path_;
   const std::string &file_name_;
+  const std::string namespace_dir_;
 };
 
 }  // namespace flatbuffers

include/flatbuffers/flatbuffers.h

@@ -337,7 +337,7 @@ public:
 
   // Change elements if you have a non-const pointer to this object.
   // Scalars only. See reflection.h, and the documentation.
-  void Mutate(uoffset_t i, T val) {
+  void Mutate(uoffset_t i, const T& val) {
     assert(i < size());
     WriteScalar(data() + i, val);
   }
@@ -1161,6 +1161,17 @@ template<typename T> const T *GetRoot(const void *buf) {
   return GetMutableRoot<T>(const_cast<void *>(buf));
 }
 
+/// Helpers to get a typed pointer to objects that are currently beeing built.
+/// @warning Creating new objects will lead to reallocations and invalidates the pointer!
+template<typename T> T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
+  return reinterpret_cast<T *>(fbb.GetCurrentBufferPointer() +
+    fbb.GetSize() - offset.o);
+}
+
+template<typename T> const T *GetTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
+  return GetMutableTemporaryPointer<T>(fbb, offset);
+}
+
 // Helper to see if the identifier in a buffer has the expected value.
 inline bool BufferHasIdentifier(const void *buf, const char *identifier) {
   return strncmp(reinterpret_cast<const char *>(buf) + sizeof(uoffset_t),
@@ -1495,6 +1506,35 @@ volatile __attribute__((weak)) const char *flatbuffer_version_string =
 
 #endif  // !defined(_WIN32) && !defined(__CYGWIN__)
 
+#define DEFINE_BITMASK_OPERATORS(E, T)\
+    inline E operator | (E lhs, E rhs){\
+        return E(T(lhs) | T(rhs));\
+    }\
+    inline E operator & (E lhs, E rhs){\
+        return E(T(lhs) & T(rhs));\
+    }\
+    inline E operator ^ (E lhs, E rhs){\
+        return E(T(lhs) ^ T(rhs));\
+    }\
+    inline E operator ~ (E lhs){\
+        return E(~T(lhs));\
+    }\
+    inline E operator |= (E &lhs, E rhs){\
+        lhs = lhs | rhs;\
+        return lhs;\
+    }\
+    inline E operator &= (E &lhs, E rhs){\
+        lhs = lhs & rhs;\
+        return lhs;\
+    }\
+    inline E operator ^= (E &lhs, E rhs){\
+        lhs = lhs ^ rhs;\
+        return lhs;\
+    }\
+    inline bool operator !(E rhs) \
+    {\
+        return !bool(T(rhs)); \
+    }
 /// @endcond
 }  // namespace flatbuffers