Issue 4991 - [emscripten] Update to Emscripten 1.37.3

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;
+    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 181 matching lines @@
     if (!property.setter.empty())
       result += ", set: " + wrapCall(property.setter);
     return result;
   }
 
   void printHelpers()
   {
     printf("var sizeofString = %i;\n", sizeof(String));
 
     puts(R"(
-  function copyString(str, buffer)
-  {
-    var length = str.length;
-    for (var i = 0, pointer = (buffer >> 1); i < length; i++, pointer++)
-      HEAP16[pointer] = str.charCodeAt(i);
-    return length;
-  }
-
-  function createString(str)
-  {
-    var length = 0;
-    var buffer = 0;
-    if (str)
-    {
-      buffer = Runtime.stackAlloc(str.length * 2);
-      length = copyString(str, buffer);
-    }
-
-    var result = Runtime.stackAlloc(sizeofString);

[Wladimir Palant, 2017/03/15 11:02:48]

We don't need to call this via Module, and above we don't. Then we don't need to
export this symbol either.

-    Module._InitString(result, buffer, length);
-    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, 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 + ref_counted_offset);
-    };
-    return result;
-  }
+      function copyString(str, buffer)
+      {
+        var length = str.length;
+        for (var i = 0, pointer = (buffer >> 1); i < length; i++, pointer++)
+          HEAP16[pointer] = str.charCodeAt(i);
+        return length;
+      }
+
+      function createString(str)
+      {
+        var length = 0;
+        var buffer = 0;
+        if (str)
+        {
+          buffer = Runtime.stackAlloc(str.length * 2);
+          length = copyString(str, buffer);
+        }
+
+        var result = Runtime.stackAlloc(sizeofString);
+        Module._InitString(result, buffer, length);
+        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, 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 + ref_counted_offset);
+        };
+        return result;
+      }
     )");

[Wladimir Palant, 2017/03/15 11:02:48]

Surprisingly, this is the only change that was really required for Emscripten
upgrade. For some reason, without this line break the closing curly bracket
isn't being printed.

[sergei, 2017/03/20 17:41:49]

Should spaces at the beginning of `    )");` be removed?
It also concerns prefixing spaces (2 spaces) for all lines of the string
literal.

[sergei, 2017/03/20 17:41:49]

Actually the whole last line is removed. I think it's a bug in compiler.

[Wladimir Palant, 2017/03/21 10:18:59]

Luckily, we don't care about the resulting code being particularly beautiful,
the uglyfier will remove any extra whitespace anyway. But indentation is indeed
strange here, I've changed it to match the indentation of surrounding code.

   }
 
   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)
@@ skipping 97 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)) -
-        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;
   }
 };