Line data    Source code

       1             : // Copyright 2016 Wladimir J. van der Laan
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or https://opensource.org/licenses/mit-license.php.
       4             : #ifndef BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H
       5             : #define BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H
       6             : 
       7             : #include <string>
       8             : 
       9             : /**
      10             :  * Filter that generates and validates UTF-8, as well as collates UTF-16
      11             :  * surrogate pairs as specified in RFC4627.
      12             :  */
      13             : class JSONUTF8StringFilter
      14             : {
      15             : public:
      16     9083875 :     explicit JSONUTF8StringFilter(std::string& s)
      17     4541938 :         : str(s)
      18     4541937 :     {
      19     9083875 :     }
      20             :     // Write single 8-bit char (may be part of UTF-8 sequence)
      21   303986558 :     void push_back(unsigned char ch)
      22             :     {
      23   303986558 :         if (state == 0) {
      24   303985189 :             if (ch < 0x80) // 7-bit ASCII, fast direct pass-through
      25   303984601 :                 str.push_back(ch);
      26         588 :             else if (ch < 0xc0) // Mid-sequence character, invalid in this state
      27           3 :                 is_valid = false;
      28         585 :             else if (ch < 0xe0) { // Start of 2-byte sequence
      29          61 :                 codepoint = (ch & 0x1f) << 6;
      30          61 :                 state = 6;
      31         585 :             } else if (ch < 0xf0) { // Start of 3-byte sequence
      32         263 :                 codepoint = (ch & 0x0f) << 12;
      33         263 :                 state = 12;
      34         524 :             } else if (ch < 0xf8) { // Start of 4-byte sequence
      35         261 :                 codepoint = (ch & 0x07) << 18;
      36         261 :                 state = 18;
      37         261 :             } else // Reserved, invalid
      38           0 :                 is_valid = false;
      39   303985189 :         } else {
      40        1369 :             if ((ch & 0xc0) != 0x80) // Not a continuation, invalid
      41           0 :                 is_valid = false;
      42        1369 :             state -= 6;
      43        1369 :             codepoint |= (ch & 0x3f) << state;
      44        1369 :             if (state == 0)
      45         584 :                 push_back_u(codepoint);
      46             :         }
      47   303986558 :     }
      48             :     // Write codepoint directly, possibly collating surrogate pairs
      49        1747 :     void push_back_u(unsigned int codepoint_)
      50             :     {
      51        1747 :         if (state) // Only accept full codepoints in open state
      52           0 :             is_valid = false;
      53        1747 :         if (codepoint_ >= 0xD800 && codepoint_ < 0xDC00) { // First half of surrogate pair
      54         273 :             if (surpair) // Two subsequent surrogate pair openers - fail
      55           0 :                 is_valid = false;
      56             :             else
      57         273 :                 surpair = codepoint_;
      58        1747 :         } else if (codepoint_ >= 0xDC00 && codepoint_ < 0xE000) { // Second half of surrogate pair
      59         273 :             if (surpair) { // Open surrogate pair, expect second half
      60             :                 // Compute code point from UTF-16 surrogate pair
      61         272 :                 append_codepoint(0x10000 | ((surpair - 0xD800)<<10) | (codepoint_ - 0xDC00));
      62         272 :                 surpair = 0;
      63         272 :             } else // Second half doesn't follow a first half - fail
      64           1 :                 is_valid = false;
      65         273 :         } else {
      66        1201 :             if (surpair) // First half of surrogate pair not followed by second - fail
      67           0 :                 is_valid = false;
      68             :             else
      69        1201 :                 append_codepoint(codepoint_);
      70             :         }
      71        1747 :     }
      72             :     // Check that we're in a state where the string can be ended
      73             :     // No open sequences, no open surrogate pairs, etc
      74     4541930 :     bool finalize()
      75             :     {
      76     4541930 :         if (state || surpair)
      77           2 :             is_valid = false;
      78     4541930 :         return is_valid;
      79             :     }
      80             : private:
      81             :     std::string &str;
      82     4541938 :     bool is_valid{true};
      83             :     // Current UTF-8 decoding state
      84     4541938 :     unsigned int codepoint{0};
      85     4541938 :     int state{0}; // Top bit to be filled in for next UTF-8 byte, or 0
      86             : 
      87             :     // Keep track of the following state to handle the following section of
      88             :     // RFC4627:
      89             :     //
      90             :     //    To escape an extended character that is not in the Basic Multilingual
      91             :     //    Plane, the character is represented as a twelve-character sequence,
      92             :     //    encoding the UTF-16 surrogate pair.  So, for example, a string
      93             :     //    containing only the G clef character (U+1D11E) may be represented as
      94             :     //    "\uD834\uDD1E".
      95             :     //
      96             :     //  Two subsequent \u.... may have to be replaced with one actual codepoint.
      97     4541938 :     unsigned int surpair{0}; // First half of open UTF-16 surrogate pair, or 0
      98             : 
      99        1473 :     void append_codepoint(unsigned int codepoint_)
     100             :     {
     101        1473 :         if (codepoint_ <= 0x7f)
     102         176 :             str.push_back((char)codepoint_);
     103        1297 :         else if (codepoint_ <= 0x7FF) {
     104         111 :             str.push_back((char)(0xC0 | (codepoint_ >> 6)));
     105         111 :             str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
     106        1297 :         } else if (codepoint_ <= 0xFFFF) {
     107         654 :             str.push_back((char)(0xE0 | (codepoint_ >> 12)));
     108         654 :             str.push_back((char)(0x80 | ((codepoint_ >> 6) & 0x3F)));
     109         654 :             str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
     110        1186 :         } else if (codepoint_ <= 0x1FFFFF) {
     111         532 :             str.push_back((char)(0xF0 | (codepoint_ >> 18)));
     112         532 :             str.push_back((char)(0x80 | ((codepoint_ >> 12) & 0x3F)));
     113         532 :             str.push_back((char)(0x80 | ((codepoint_ >> 6) & 0x3F)));
     114         532 :             str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
     115         532 :         }
     116        1473 :     }
     117             : };
     118             : 
     119             : #endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H