Issue 5201 - [emscripten] Replace EM_ASM calls by a custom JavaScript library

compiled/library.js

Index: compiled/library.js
===================================================================
new file mode 100644
--- /dev/null
+++ b/compiled/library.js
@@ -0,0 +1,87 @@
+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2017 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+"use strict";
+
+mergeInto(LibraryManager.library, {
+  LogString: function(str)
+  {
+    console.log(readString(str));
+  },
+
+  LogInteger: function(i)
+  {
+    console.log(i);
+  },
+
+  LogPointer: function(ptr)
+  {
+    console.log(ptr);
+  },
+
+  LogError: function(str)
+  {
+    console.error(new Error(readString(str)).stack);
+  },
+
+  CharToLower: function(charCode)
+  {
+    return String.fromCharCode(charCode).toLowerCase().charCodeAt(0);

[sergei, 2017/05/02 09:48:06]

Coming back to
https://codereview.adblockplus.org/29333474/diff/29336116/compiled/ActiveFilt...
and the question about lower casing of UTF-8 (whether it maps to the same number
of bytes), I think we need to look into it later and find out a proper solution,
maybe even negotiate with filter list maintainers some constraints.

"Σ".toLowerCase() /* => ς*/.charCodeAt(0) => 962
"Σa".toLowerCase() /* => σa*/[0].charCodeAt(0) => 963

[Wladimir Palant, 2017/05/03 11:57:17]

I cannot reproduce that - neither in Firefox nor in Chrome nor in Node. Where
did you get 962 as result?

[sergei, 2017/05/03 13:24:04]

Only in Chrome but I'm on Windows, additional info
https://en.wiktionary.org/wiki/ς.
It's one of the most famous cases German ß<>SS and Turkish i which are often
recalled.

I think all implementation have some restrictions and some have even bugs, we
could simply document the restrictions in a convenient for us way.

According to ECMA-262 String.prototype.toLowerCase
(http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype.tolowercase)
uses UnicodeData.txt and locale-insensitive mappings from SpecialCasings.txt,
what versions though? We could also say that our implementation does not take
into account context, it's locale-insensitive and works only for the characters
from these particular our (e.g. based on UnicodeData.txt and SpecialCasings.txt)
files and the everything else would be officially undefined behavior. Locally we
could inspect all conversions defined in those files, check whether there are
some cases when the size after lowering/uppering is different for UTF-8,
periodically update the files in accordance to the actual results from used
libraries, etc.

[Wladimir Palant, 2017/05/04 09:14:27]

We are only using this functionality on domain names, in order to bring these
into the canonical form. Most of the time we should have the data in the
canonical form already. And I think that chances of somebody using an upper-case
Greek domain name in a filter are rather slim.

In the end, typing ΑΝΑΝΆΣ.gr into the browser produces ανανάσ.gr and not
ανανάς.gr in both Firefox and Chrome for me - so the browsers have issues here
as well (interesting that you get different results on Windows though). I guess
that anybody using such a domain name will be careful to always specify it in
the lower-cased form.

[Wladimir Palant, 2017/05/04 09:35:19]

Going through the locale-insensitive mappings in
ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt, it seems that
Greek sigma is the only letter that is "special" with regards to lowercasing.
All the other special cases listed only relate to uppercasing. So if we really
run into issues here, we could simply add an additional code path for this one
letter.

+  },
+
+  JSNotifyFilterChange: function(topic, filter)
+  {
+    FilterNotifier.triggerListeners(notifierTopics.get(topic),
+        exports.Filter.fromPointer(filter));
+  },
+
+  JSNotifySubscriptionChange: function(topic, subscription)
+  {
+    FilterNotifier.triggerListeners(notifierTopics.get(topic),
+        exports.Subscription.fromPointer(subscription));
+  },
+
+  $_regexp_data: Object.create(null),
+  $_regexp_counter: 0,
+
+  GenerateRegExp__deps: ["$_regexp_data", "$_regexp_counter"],
+  GenerateRegExp: function(source, matchCase)
+  {
+    var id = ++_regexp_counter;
+    try
+    {
+      _regexp_data[id] = new RegExp(readString(source), matchCase ? "" : "i");
+      return id;
+    }
+    catch (e)
+    {
+      return -1;
+    }
+  },
+
+  DeleteRegExp__deps: ["$_regexp_data"],
+  DeleteRegExp: function(id)
+  {
+    delete _regexp_data[id];
+  },
+
+  TestRegExp__deps: ["$_regexp_data"],
+  TestRegExp: function(id, str)
+  {
+    return _regexp_data[id].test(readString(str));
+  }
+});