Issue 5603 - Support references in parameters of exported functions

compiled/bindings/generator.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 51 matching lines @@
       case TypeCategory::FLOAT:
         signature += 'f';
         break;
       case TypeCategory::DOUBLE:
         signature += 'd';
         break;
       case TypeCategory::INT:
       case TypeCategory::INT64:
       case TypeCategory::STRING_REF:
       case TypeCategory::CLASS_PTR:
+      case TypeCategory::CLASS_REF:
         signature += 'i';
         break;
       default:
         throw std::runtime_error("Unexpected function return type");
     }
 
     // `this` pointer is an implicit parameter with clang and should be added
     // to the signature.
     if (instance_function)
       signature += 'i';
 
     // Add explicit parameters to the signature, Similar logic in Emscripten:
     // https://github.com/kripken/emscripten/blob/1.37.3/src/modules.js#L67
     for (const auto& type : argTypes)
     {
       switch (type)
       {
         case TypeCategory::INT:
         case TypeCategory::STRING_REF:
         case TypeCategory::CLASS_PTR:
+        case TypeCategory::CLASS_REF:
           signature += 'i';
           break;
         case TypeCategory::INT64:
           // See https://github.com/kripken/emscripten/blob/1.37.3/src/modules.js#L73,
           // numerical types larger than 32-bit are split into multiple
           // 32-bit parameters.
           signature += "ii";
           break;
         case TypeCategory::FLOAT:
           signature += 'f';
@@ skipping 136 matching lines @@
         std::string result;
         result += "  var string = createOwnedString();\n";
         result += "  " + call_str + ";\n";
         result += "  var result = readString(string);\n";
         result += "  Module._DestroyString(string);\n";
         return result;
       }
       case TypeCategory::STRING_REF:
         return "  var result = readString(" + call_str + ");\n";
       case TypeCategory::CLASS_PTR:
+      case TypeCategory::CLASS_REF:
       {
         std::string result;
         result += "  var result = " + call_str + ";\n";
         result += "  if (result)\n";
 
         const ClassInfo* cls = find_class(call.pointerType);
         if (!cls)
           throw std::runtime_error("Function " + call.name + " returns pointer to unknown class");
 
         auto offset = cls->subclass_differentiator.offset;
@@ skipping 28 matching lines @@
         prefix += ", ";
       prefix += argName;
 
       if (call.args[i] == TypeCategory::STRING_REF)
       {
         hasStringArgs = true;
         params.push_back(std::string("createString(") + argName + ")");
       }
       else if (call.args[i] == TypeCategory::CLASS_PTR)
         params.push_back(argName + " ? " + argName + "._pointer : 0");
+      else if (call.args[i] == TypeCategory::CLASS_REF)
+        params.push_back(argName + "._pointer");

[Wladimir Palant, 2017/08/31 12:37:39]

This is an implicit null check, should be good enough IMHO.

[sergei, 2017/08/31 12:59:20]

LGTM, though not tested.

       else if (call.args[i] == TypeCategory::INT64)
       {
         // 64-bit integers are passed as two integer parameters
         params.push_back(argName + " >>> 0");
         params.push_back(argName + " / 0x100000000 >>> 0");
       }
       else
         params.push_back(argName);
     }
     prefix += ")\n{\n";
@@ skipping 172 matching lines @@
 
 void printBindings()
 {
   bindings_internal::printHelpers();
 
   for (const auto& cls : classes)
     bindings_internal::printClass(cls);
   for (const auto& cls : classes)
     bindings_internal::printClassMapping(cls);
 }