HL: fast path for ascii delimiters

We can use a bit set for ascii delimiters. All our syntax definitions
use use ASCII so this is a clear win. We still leave the old path for
non ASCII delimiters.

This brings up in the 1100-1000 msec (originally from 1500-1400).

```
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:13  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1098
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:17  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1104
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:20  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1127
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:24  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1105
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:27  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1139
[qutepart-cpp] ./cbuild/editor ~/benchmark.cpp                                                                          22:10:31  ☁  main ☂ 𝝙 ⚡ ✭ 𝝙
Loading itme =  1087

```

refs #73

Author: diegoiast

src/hl/rules.cpp

@@ -128,7 +128,7 @@ void KeywordRule::setKeywordParams(const QHash<QString, QStringList> &lists, boo
         return;
     }
     this->caseSensitive = newCaseSensitive;
-    this->deliminators = newDeliminators;
+    this->deliminators = DeliminatorSet(newDeliminators);
 
     items.clear();
     const auto &list = lists[listName];
@@ -232,7 +232,7 @@ bool WordDetectRule::tryMatchImpl(const TextToMatch &textToMatch, MatchResult &r
 
 void WordDetectRule::setKeywordParams(const QHash<QString, QStringList> &, bool,
                                       const QString &deliminatorSet, QString &) {
-    mDeliminatorSet = deliminatorSet;
+    mDeliminatorSet = DeliminatorSet(deliminatorSet);
 }
 
 RegExpRule::RegExpRule(const AbstractRuleParams &params, const QString &value, bool insensitive,

src/hl/rules.h

@@ -13,6 +13,7 @@
 #include <QTextStream>
 
 #include "context.h"
+#include "text_to_match.h"
 
 namespace Qutepart {
 
@@ -105,7 +106,7 @@ class KeywordRule : public AbstractRule {
     QString listName;
     QHash<QString, bool> items;
     bool caseSensitive;
-    QString deliminators;
+    DeliminatorSet deliminators;
 };
 
 class DetectCharRule : public AbstractRule {
@@ -162,7 +163,7 @@ class WordDetectRule : public AbstractStringRule {
 
   private:
     virtual bool tryMatchImpl(const TextToMatch &textToMatch, MatchResult &result) const override;
-    QString mDeliminatorSet;
+    DeliminatorSet mDeliminatorSet;
 };
 
 class RegExpRule : public AbstractRule {

src/hl/text_to_match.cpp

@@ -8,6 +8,25 @@
 
 namespace Qutepart {
 
+DeliminatorSet::DeliminatorSet(const QString &deliminators) {
+    for (QChar ch : deliminators) {
+        ushort code = ch.unicode();
+        if (code < asciiChars_.size()) {
+            asciiChars_.set(code);
+        } else {
+            nonAsciiChars_.append(ch);
+        }
+    }
+}
+
+bool DeliminatorSet::contains(QChar ch) const {
+    ushort code = ch.unicode();
+    if (code < asciiChars_.size()) {
+        return asciiChars_.test(code);
+    }
+    return nonAsciiChars_.contains(ch);
+}
+
 TextToMatch::TextToMatch(const QString &text, const QStringList &contextData)
     : currentColumnIndex(0), wholeLineText(text), text(wholeLineText.left(wholeLineText.length())),
       textLength(text.length()), firstNonSpace(true), // copy-paste from Py code
@@ -42,25 +61,25 @@ void TextToMatch::shift(int count) {
 
 bool TextToMatch::isEmpty() const { return text.isEmpty(); }
 
-QString TextToMatch::word(const QString &deliminatorSet) const {
+QStringView TextToMatch::word(const DeliminatorSet &deliminators) const {
     if (currentColumnIndex > 0) {
         QChar prevChar = wholeLineText[currentColumnIndex - 1];
-        if (!deliminatorSet.contains(prevChar)) {
-            return QString();
+        if (!deliminators.contains(prevChar)) {
+            return QStringView();
         }
     }
 
     int wordEndIndex = 0;
     for (; wordEndIndex < text.length(); wordEndIndex++) {
-        if (deliminatorSet.contains(text.at(wordEndIndex))) {
+        if (deliminators.contains(text.at(wordEndIndex))) {
             break;
         }
     }
     if (wordEndIndex != 0) {
-        return text.left(wordEndIndex).toString();
+        return text.left(wordEndIndex);
     }
 
-    return QString();
+    return QStringView();
 }
 
 } // namespace Qutepart

src/hl/text_to_match.h

@@ -6,10 +6,29 @@
 
 #pragma once
 
+#include <bitset>
+
 #include <QString>
 
 namespace Qutepart {
 
+/* A set of "word deliminator" characters, with O(1) membership testing.
+ * Built once (when a rule's deliminator string is set) and reused on every
+ * character checked while extracting a word - avoids rescanning the
+ * deliminator string for every character of every candidate word.
+ */
+class DeliminatorSet {
+  public:
+    DeliminatorSet() = default;
+    explicit DeliminatorSet(const QString &deliminators);
+
+    bool contains(QChar ch) const;
+
+  private:
+    std::bitset<128> asciiChars_;
+    QString nonAsciiChars_; // deliminators outside ASCII range; expected to be empty in practice
+};
+
 /* Peace of text, which shall be matched.
  * Contains pre-calculated and pre-checked data for performance optimization
  */
@@ -22,7 +41,7 @@ class TextToMatch {
 
     bool isEmpty() const;
 
-    QString word(const QString &deliminators) const;
+    QStringView word(const DeliminatorSet &deliminators) const;
 
     int currentColumnIndex;
     QString wholeLineText;