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;
+    ptrdiff_t ref_counted_offset;
   };
 
   std::map<TYPEID, ClassInfo> classes;
 
-  void register_class(const char* name, TYPEID classID, TYPEID baseClassID)
+  void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
+                      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())
         throw std::runtime_error(std::string("Unknown base class defined for class ") + name);
       baseClass = &(it->second);
     }
 
     ClassInfo classInfo;
     classInfo.baseClass = baseClass;
     classInfo.name = name;
     classInfo.subclass_differentiator.offset = SIZE_MAX;
+    classInfo.ref_counted_offset = ref_counted_offset;
     classes[classID] = classInfo;
   }
 
   void register_property(TYPEID classID, const char* name,
       const FunctionInfo& getter, const FunctionInfo& setter,
       const char* jsValue = "")
   {
     auto it = classes.find(classID);
     if (it == classes.end())
       throw std::runtime_error(std::string("Property defined on unknown class: ") + name);
@@ skipping 192 matching lines @@
     return result;
   }
 
   function readString(str)
   {
     var length = Module._GetStringLength(str);
     var pointer = Module._GetStringData(str) >> 1;
     return String.fromCharCode.apply(String, HEAP16.slice(pointer, pointer + length));
   }
 
-  function createClass(superclass)
+  function createClass(superclass, ref_counted_offset)
   {
     var result = function(pointer)
     {
       this._pointer = pointer;
     };
     if (superclass)
       result.prototype = Object.create(superclass.prototype);
     result.prototype.delete = function()
     {
-      Module._ReleaseRef(this._pointer);
+      Module._ReleaseRef(this._pointer + ref_counted_offset);
     };
     return result;
   })");
   }
 
   void printClass(const ClassInfo& cls)
   {
     DifferentiatorInfo differentiator = cls.subclass_differentiator;
     if (differentiator.offset != SIZE_MAX)
     {
       printf("var %s_mapping = \n", cls.name.c_str());
       puts("{");
       for (const auto& item : differentiator.mapping)
         printf("  %i: '%s',\n", item.first, item.second.c_str());
       puts("};");
     }
 
-    printf("exports.%s = createClass(%s);\n", cls.name.c_str(),
-        (cls.baseClass ? ("exports." + cls.baseClass->name).c_str() : ""));
+    printf("exports.%s = createClass(%s, %i);\n", cls.name.c_str(),
+        (cls.baseClass ? ("exports." + cls.baseClass->name).c_str() : "null"),
+        cls.ref_counted_offset);
 
     for (const auto& item : cls.properties)
     {
       printf("Object.defineProperty(exports.%s.prototype, '%s', {%s});\n",
           cls.name.c_str(), item.name.c_str(),
           generatePropertyDescriptor(item).c_str());
     }
 
     for (const auto& item : cls.methods)
     {
@@ skipping 63 matching lines @@
         String::size_type EMSCRIPTEN_KEEPALIVE GetStringLength(\
             const String& str)\
         {\
           return str.length();\
         }\
         const String::value_type* EMSCRIPTEN_KEEPALIVE GetStringData(\
             const String& str)\
         {\
           return str.data();\
         }\
-        void EMSCRIPTEN_KEEPALIVE AddRef(ref_counted* ptr)\
-        {\
-          ptr->AddRef();\
-        }\
         void EMSCRIPTEN_KEEPALIVE ReleaseRef(ref_counted* ptr)\
         {\
           ptr->ReleaseRef();\
         }\
       }\
       void BindingsInitializer_dummy()
 #endif
 
 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);
+    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>());
+        bindings_internal::TypeInfo<BaseClass>(),
+        ref_counted_offset
+      );
   }
 
   template<typename FieldType>
   const class_& property(const char* name,
       FieldType (ClassType::*getter)() const,
       void (ClassType::*setter)(FieldType) = nullptr) const
   {
     bindings_internal::register_property(
         bindings_internal::TypeInfo<ClassType>(), name, getter, setter);
     return *this;
@@ skipping 50 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;
   }
 };