Issue 4125 - [emscripten] Convert filter classes to C++

compiled/bindings.ipp

 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <exception>
 #include <map>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
@@ skipping 257 matching lines @@
   };
 
   struct ClassInfo
   {
     ClassInfo* baseClass;
     std::string name;
     std::vector<PropertyInfo> properties;
     std::vector<MethodInfo> methods;
     std::vector<FunctionInfo> initializers;
     DifferentiatorInfo subclass_differentiator;
-    int ref_counted_offset;

[sergei, 2017/03/20 17:07:18]

Can we use ptrdiff_t for ref_counted_offset?

[Wladimir Palant, 2017/03/21 10:10:15]

Done.

+    ptrdiff_t ref_counted_offset;
   };
 
   std::map<TYPEID, ClassInfo> classes;
 
   void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
-                      int ref_counted_offset)
+                      ptrdiff_t ref_counted_offset)
   {
     auto it = classes.find(classID);
     if (it != classes.end())
       throw std::runtime_error(std::string("Duplicate definition for class ") + name);
 
     ClassInfo* baseClass = nullptr;
     if (baseClassID != TypeInfo<NoBaseClass>())
     {
       it = classes.find(baseClassID);
       if (it == classes.end())
@@ skipping 342 matching lines @@
 
 template<typename ClassType,
     typename BaseClass = bindings_internal::NoBaseClass,
     typename std::enable_if<std::is_base_of<ref_counted, ClassType>::value>::type* = nullptr>
 class class_
 {
 public:
   class_(const char* name)
   {
     ClassType* ptr = reinterpret_cast<ClassType*>(0x10000000);
-    int ref_counted_offset =
-        reinterpret_cast<int>(dynamic_cast<ref_counted*>(ptr)) -

[sergei, 2017/03/20 17:07:15]

Could we please use static_cast instead of dynamic_cast here because I find it
very unreliable because I expect that dynamic_cast uses run time info, in
particular it likely reads vtable (maybe a value at some negative offset) which
is absent here.

I would say it's still a hack and so far the offset is always zero, so what do
you think about having of some warning when the offset is not zero to come back
and check that it still works correctly.

BTW, in general I think this code does not always work, e.g. with some virtual
inheritance  but I think it will never our case and I think static_cast will do
its work in this case.

[Wladimir Palant, 2017/03/21 10:10:12]

Done.
I did test this code of course by changing the inheritance structure in such a
way that the offset is no longer zero.

-        reinterpret_cast<int>(ptr);
+    ptrdiff_t ref_counted_offset =
+        reinterpret_cast<char*>(static_cast<ref_counted*>(ptr)) -
+        reinterpret_cast<char*>(ptr);
     bindings_internal::register_class(name,
         bindings_internal::TypeInfo<ClassType>(),
         bindings_internal::TypeInfo<BaseClass>(),
         ref_counted_offset
       );
   }
 
   template<typename FieldType>
   const class_& property(const char* name,
       FieldType (ClassType::*getter)() const,
@@ skipping 55 matching lines @@
 
     std::vector<std::pair<int, std::string>> mapping;
     for (const auto& item : list)
       mapping.emplace_back(item.first, item.second);
 
     bindings_internal::register_differentiator(
         bindings_internal::TypeInfo<ClassType>(), offset, mapping);
     return *this;
   }
 };