Branch data     Line data    Source code

       1                 :            : // Copyright 2014 BitPay Inc.
       2                 :            : // Distributed under the MIT software license, see the accompanying
       3                 :            : // file COPYING or https://opensource.org/licenses/mit-license.php.
       4                 :            : 
       5                 :            : #include <univalue.h>
       6                 :            : #include <univalue_escapes.h>
       7                 :            : 
       8                 :            : #include <memory>
       9                 :            : #include <string>
      10                 :            : #include <vector>
      11                 :            : 
      12                 :    2992812 : static std::string json_escape(const std::string& inS)
      13                 :            : {
      14                 :    2992812 :     std::string outS;
      15         [ +  - ]:    2992812 :     outS.reserve(inS.size() * 2);
      16                 :            : 
      17         [ +  + ]:   56013134 :     for (unsigned int i = 0; i < inS.size(); i++) {
      18                 :   53020322 :         unsigned char ch = static_cast<unsigned char>(inS[i]);
      19                 :   53020322 :         const char *escStr = escapes[ch];
      20                 :            : 
      21         [ +  + ]:   53020322 :         if (escStr)
      22         [ +  - ]:      58970 :             outS += escStr;
      23                 :            :         else
      24         [ +  - ]:   52961352 :             outS += static_cast<char>(ch);
      25                 :   53020322 :     }
      26                 :            : 
      27                 :    2992812 :     return outS;
      28         [ +  - ]:    2992812 : }
      29                 :            : 
      30                 :    3077354 : std::string UniValue::write(unsigned int prettyIndent,
      31                 :            :                             unsigned int indentLevel) const
      32                 :            : {
      33                 :    3077354 :     std::string s;
      34         [ +  - ]:    3077354 :     s.reserve(1024);
      35                 :            : 
      36                 :    3077354 :     unsigned int modIndent = indentLevel;
      37         [ +  + ]:    3077354 :     if (modIndent == 0)
      38                 :       2326 :         modIndent = 1;
      39                 :            : 
      40   [ +  +  +  +  :    3077354 :     switch (typ) {
                +  +  - ]
      41                 :            :     case VNULL:
      42         [ +  - ]:        230 :         s += "null";
      43                 :        230 :         break;
      44                 :            :     case VOBJ:
      45         [ +  - ]:     603385 :         writeObject(prettyIndent, modIndent, s);
      46                 :     603385 :         break;
      47                 :            :     case VARR:
      48         [ +  - ]:      43281 :         writeArray(prettyIndent, modIndent, s);
      49                 :      43281 :         break;
      50                 :            :     case VSTR:
      51   [ +  -  +  -  :     591353 :         s += "\"" + json_escape(val) + "\"";
             +  -  +  - ]
      52                 :     591353 :         break;
      53                 :            :     case VNUM:
      54         [ +  - ]:    1838595 :         s += val;
      55                 :    1838595 :         break;
      56                 :            :     case VBOOL:
      57   [ +  -  +  - ]:        510 :         s += (val == "1" ? "true" : "false");
      58                 :        510 :         break;
      59                 :            :     }
      60                 :            : 
      61                 :    3077354 :     return s;
      62         [ +  - ]:    3077354 : }
      63                 :            : 
      64                 :    3575501 : static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, std::string& s)
      65                 :            : {
      66                 :    3575501 :     s.append(prettyIndent * indentLevel, ' ');
      67                 :    3575501 : }
      68                 :            : 
      69                 :      43281 : void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
      70                 :            : {
      71                 :      43281 :     s += "[";
      72         [ +  + ]:      43281 :     if (prettyIndent)
      73                 :      12882 :         s += "\n";
      74                 :            : 
      75         [ +  + ]:     703968 :     for (unsigned int i = 0; i < values.size(); i++) {
      76         [ +  + ]:     660687 :         if (prettyIndent)
      77                 :     589463 :             indentStr(prettyIndent, indentLevel, s);
      78         [ +  - ]:     660687 :         s += values[i].write(prettyIndent, indentLevel + 1);
      79         [ +  + ]:     660687 :         if (i != (values.size() - 1)) {
      80                 :     648987 :             s += ",";
      81                 :     648987 :         }
      82         [ +  + ]:     660687 :         if (prettyIndent)
      83                 :     589463 :             s += "\n";
      84                 :     660687 :     }
      85                 :            : 
      86         [ +  + ]:      43281 :     if (prettyIndent)
      87                 :      12882 :         indentStr(prettyIndent, indentLevel - 1, s);
      88                 :      43281 :     s += "]";
      89                 :      43281 : }
      90                 :            : 
      91                 :     603385 : void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
      92                 :            : {
      93                 :     603385 :     s += "{";
      94         [ +  + ]:     603385 :     if (prettyIndent)
      95                 :     602380 :         s += "\n";
      96                 :            : 
      97         [ +  + ]:    3004844 :     for (unsigned int i = 0; i < keys.size(); i++) {
      98         [ +  + ]:    2401459 :         if (prettyIndent)
      99                 :    2370776 :             indentStr(prettyIndent, indentLevel, s);
     100   [ -  +  -  +  :    2401459 :         s += "\"" + json_escape(keys[i]) + "\":";
                   -  + ]
     101         [ +  + ]:    2401459 :         if (prettyIndent)
     102                 :    2370776 :             s += " ";
     103         [ -  + ]:    2401459 :         s += values.at(i).write(prettyIndent, indentLevel + 1);
     104         [ +  + ]:    2401459 :         if (i != (values.size() - 1))
     105                 :    1799052 :             s += ",";
     106         [ +  + ]:    2401459 :         if (prettyIndent)
     107                 :    2370776 :             s += "\n";
     108                 :    2401459 :     }
     109                 :            : 
     110         [ +  + ]:     603385 :     if (prettyIndent)
     111                 :     602380 :         indentStr(prettyIndent, indentLevel - 1, s);
     112                 :     603385 :     s += "}";
     113                 :     603385 : }
     114                 :            :