tools/source/misc/json_writer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <tools/json_writer.hxx>
  11 #include <stdio.h>
  12 #include <cstring>
  13 #include <rtl/math.hxx>
  14
  15 namespace tools
  16 {
  17 /** These buffers are short-lived, so rather waste some space and avoid the cost of
  18  * repeated calls into the allocator */
  19 constexpr int DEFAULT_BUFFER_SIZE = 2048;
  20
  21 JsonWriter::JsonWriter()
  22     : mpBuffer(static_cast<char*>(malloc(DEFAULT_BUFFER_SIZE)))
  23     , mPos(mpBuffer)
  24     , mSpaceAllocated(DEFAULT_BUFFER_SIZE)
  25     , mStartNodeCount(0)
  26     , mbFirstFieldInNode(true)
  27 {
  28     *mPos = '{';
  29     ++mPos;
  30     *mPos = ' ';
  31     ++mPos;
  32
  33     addValidationMark();
  34 }
  35
  36 JsonWriter::~JsonWriter()
  37 {
  38     assert(!mpBuffer && "forgot to extract data?");
  39     free(mpBuffer);
  40 }
  41
  42 ScopedJsonWriterNode JsonWriter::startNode(const char* pNodeName)
  43 {
  44     auto len = strlen(pNodeName);
  45     ensureSpace(len + 8);
  46
  47     addCommaBeforeField();
  48
  49     *mPos = '"';
  50     ++mPos;
  51     memcpy(mPos, pNodeName, len);
  52     mPos += len;
  53     memcpy(mPos, "\": { ", 5);
  54     mPos += 5;
  55     mStartNodeCount++;
  56     mbFirstFieldInNode = true;
  57
  58     validate();
  59
  60     return ScopedJsonWriterNode(*this);
  61 }
  62
  63 void JsonWriter::endNode()
  64 {
  65     assert(mStartNodeCount && "mismatched StartNode/EndNode somewhere");
  66     --mStartNodeCount;
  67     ensureSpace(1);
  68     *mPos = '}';
  69     ++mPos;
  70     mbFirstFieldInNode = false;
  71
  72     validate();
  73 }
  74
  75 ScopedJsonWriterArray JsonWriter::startArray(const char* pNodeName)
  76 {
  77     auto len = strlen(pNodeName);
  78     ensureSpace(len + 8);
  79
  80     addCommaBeforeField();
  81
  82     *mPos = '"';
  83     ++mPos;
  84     memcpy(mPos, pNodeName, len);
  85     mPos += len;
  86     memcpy(mPos, "\": [ ", 5);
  87     mPos += 5;
  88     mStartNodeCount++;
  89     mbFirstFieldInNode = true;
  90
  91     validate();
  92
  93     return ScopedJsonWriterArray(*this);
  94 }
  95
  96 void JsonWriter::endArray()
  97 {
  98     assert(mStartNodeCount && "mismatched StartNode/EndNode somewhere");
  99     --mStartNodeCount;
 100     ensureSpace(1);
 101     *mPos = ']';
 102     ++mPos;
 103     mbFirstFieldInNode = false;
 104
 105     validate();
 106 }
 107
 108 ScopedJsonWriterStruct JsonWriter::startStruct()
 109 {
 110     ensureSpace(6);
 111
 112     addCommaBeforeField();
 113
 114     *mPos = '{';
 115     ++mPos;
 116     *mPos = ' ';
 117     ++mPos;
 118     mStartNodeCount++;
 119     mbFirstFieldInNode = true;
 120
 121     validate();
 122
 123     return ScopedJsonWriterStruct(*this);
 124 }
 125
 126 void JsonWriter::endStruct()
 127 {
 128     assert(mStartNodeCount && "mismatched StartNode/EndNode somewhere");
 129     --mStartNodeCount;
 130     ensureSpace(1);
 131     *mPos = '}';
 132     ++mPos;
 133     mbFirstFieldInNode = false;
 134
 135     validate();
 136 }
 137
 138 static char getEscapementChar(char ch)
 139 {
 140     switch (ch)
 141     {
 142         case '\b':
 143             return 'b';
 144         case '\t':
 145             return 't';
 146         case '\n':
 147             return 'n';
 148         case '\f':
 149             return 'f';
 150         case '\r':
 151             return 'r';
 152         default:
 153             return ch;
 154     }
 155 }
 156
 157 static bool writeEscapedSequence(sal_uInt32 ch, char*& pos)
 158 {
 159     // control characters
 160     if (ch <= 0x1f)
 161     {
 162         // clang-format off
 163         SAL_WNODEPRECATED_DECLARATIONS_PUSH // sprintf (macOS 13 SDK)
 164         int written = sprintf(pos, "\\u%.4x", ch);
 165         SAL_WNODEPRECATED_DECLARATIONS_POP
 166         // clang-format on
 167
 168         if (written > 0)
 169             pos += written;
 170         return true;
 171     }
 172
 173     switch (ch)
 174     {
 175         case '\b':
 176         case '\t':
 177         case '\n':
 178         case '\f':
 179         case '\r':
 180         case '"':
 181         case '/':
 182         case '\\':
 183             *pos++ = '\\';
 184             *pos++ = getEscapementChar(ch);
 185             return true;
 186         // Special processing of U+2028 and U+2029, which are valid JSON, but invalid JavaScript
 187         // Write them in escaped '\u2028' or '\u2029' form
 188         case 0x2028:
 189         case 0x2029:
 190             *pos++ = '\\';
 191             *pos++ = 'u';
 192             *pos++ = '2';
 193             *pos++ = '0';
 194             *pos++ = '2';
 195             *pos++ = ch == 0x2028 ? '8' : '9';
 196             return true;
 197         default:
 198             return false;
 199     }
 200 }
 201
 202 void JsonWriter::writeEscapedOUString(const OUString& rPropVal)
 203 {
 204     // Convert from UTF-16 to UTF-8 and perform escaping
 205     sal_Int32 i = 0;
 206     while (i < rPropVal.getLength())
 207     {
 208         sal_uInt32 ch = rPropVal.iterateCodePoints(&i);
 209         if (writeEscapedSequence(ch, mPos))
 210             continue;
 211         if (ch <= 0x7F)
 212         {
 213             *mPos = static_cast<char>(ch);
 214             ++mPos;
 215         }
 216         else if (ch <= 0x7FF)
 217         {
 218             *mPos = 0xC0 | (ch >> 6); /* 110xxxxx */
 219             ++mPos;
 220             *mPos = 0x80 | (ch & 0x3F); /* 10xxxxxx */
 221             ++mPos;
 222         }
 223         else if (ch <= 0xFFFF)
 224         {
 225             *mPos = 0xE0 | (ch >> 12); /* 1110xxxx */
 226             ++mPos;
 227             *mPos = 0x80 | ((ch >> 6) & 0x3F); /* 10xxxxxx */
 228             ++mPos;
 229             *mPos = 0x80 | (ch & 0x3F); /* 10xxxxxx */
 230             ++mPos;
 231         }
 232         else
 233         {
 234             *mPos = 0xF0 | (ch >> 18); /* 11110xxx */
 235             ++mPos;
 236             *mPos = 0x80 | ((ch >> 12) & 0x3F); /* 10xxxxxx */
 237             ++mPos;
 238             *mPos = 0x80 | ((ch >> 6) & 0x3F); /* 10xxxxxx */
 239             ++mPos;
 240             *mPos = 0x80 | (ch & 0x3F); /* 10xxxxxx */
 241             ++mPos;
 242         }
 243     }
 244
 245     validate();
 246 }
 247
 248 void JsonWriter::put(const OUString& pPropName, const OUString& rPropVal)
 249 {
 250     auto nPropNameLength = pPropName.getLength();
 251     // But values can be any UTF-8,
 252     // if the string only contains of 0x2028, it will be expanded 6 times (see writeEscapedSequence)
 253     auto nWorstCasePropValLength = rPropVal.getLength() * 6;
 254     ensureSpace(nPropNameLength + nWorstCasePropValLength + 8);
 255
 256     addCommaBeforeField();
 257
 258     *mPos = '"';
 259     ++mPos;
 260
 261     writeEscapedOUString(pPropName);
 262
 263     memcpy(mPos, "\": \"", 4);
 264     mPos += 4;
 265
 266     writeEscapedOUString(rPropVal);
 267
 268     *mPos = '"';
 269     ++mPos;
 270
 271     validate();
 272 }
 273
 274 void JsonWriter::put(const char* pPropName, const OUString& rPropVal)
 275 {
 276     auto nPropNameLength = strlen(pPropName);
 277     // But values can be any UTF-8,
 278     // if the string only contains of 0x2028, it will be expanded 6 times (see writeEscapedSequence)
 279     auto nWorstCasePropValLength = rPropVal.getLength() * 6;
 280     ensureSpace(nPropNameLength + nWorstCasePropValLength + 8);
 281
 282     addCommaBeforeField();
 283
 284     *mPos = '"';
 285     ++mPos;
 286     memcpy(mPos, pPropName, nPropNameLength);
 287     mPos += nPropNameLength;
 288     memcpy(mPos, "\": \"", 4);
 289     mPos += 4;
 290
 291     writeEscapedOUString(rPropVal);
 292
 293     *mPos = '"';
 294     ++mPos;
 295
 296     validate();
 297 }
 298
 299 void JsonWriter::put(const char* pPropName, std::string_view rPropVal)
 300 {
 301     // we assume property names are ascii
 302     auto nPropNameLength = strlen(pPropName);
 303     // escaping can double the length
 304     auto nWorstCasePropValLength = rPropVal.size() * 2;
 305     ensureSpace(nPropNameLength + nWorstCasePropValLength + 8);
 306
 307     addCommaBeforeField();
 308
 309     *mPos = '"';
 310     ++mPos;
 311     memcpy(mPos, pPropName, nPropNameLength);
 312     mPos += nPropNameLength;
 313     memcpy(mPos, "\": \"", 4);
 314     mPos += 4;
 315
 316     // copy and perform escaping
 317     bool bReachedEnd = false;
 318     for (size_t i = 0; i < rPropVal.size() && !bReachedEnd; ++i)
 319     {
 320         char ch = rPropVal[i];
 321         switch (ch)
 322         {
 323             case '\b':
 324             case '\t':
 325             case '\n':
 326             case '\f':
 327             case '\r':
 328             case '"':
 329             case '/':
 330             case '\\':
 331                 writeEscapedSequence(ch, mPos);
 332                 break;
 333             case 0:
 334                 bReachedEnd = true;
 335                 break;
 336             case '\xE2': // Special processing of U+2028 and U+2029
 337                 if (i + 2 < rPropVal.size() && rPropVal[i + 1] == '\x80'
 338                     && (rPropVal[i + 2] == '\xA8' || rPropVal[i + 2] == '\xA9'))
 339                 {
 340                     writeEscapedSequence(rPropVal[i + 2] == '\xA8' ? 0x2028 : 0x2029, mPos);
 341                     i += 2;
 342                     break;
 343                 }
 344                 [[fallthrough]];
 345             default:
 346                 *mPos = ch;
 347                 ++mPos;
 348                 break;
 349         }
 350     }
 351
 352     *mPos = '"';
 353     ++mPos;
 354
 355     validate();
 356 }
 357
 358 void JsonWriter::put(const char* pPropName, sal_Int64 nPropVal)
 359 {
 360     auto nPropNameLength = strlen(pPropName);
 361     auto nWorstCasePropValLength = 32;
 362     ensureSpace(nPropNameLength + nWorstCasePropValLength + 8);
 363
 364     addCommaBeforeField();
 365
 366     *mPos = '"';
 367     ++mPos;
 368     memcpy(mPos, pPropName, nPropNameLength);
 369     mPos += nPropNameLength;
 370     memcpy(mPos, "\": ", 3);
 371     mPos += 3;
 372
 373     // clang-format off
 374     SAL_WNODEPRECATED_DECLARATIONS_PUSH // sprintf (macOS 13 SDK)
 375     mPos += sprintf(mPos, "%" SAL_PRIdINT64, nPropVal);
 376     SAL_WNODEPRECATED_DECLARATIONS_POP
 377     // clang-format on
 378
 379     validate();
 380 }
 381
 382 void JsonWriter::put(const char* pPropName, double fPropVal)
 383 {
 384     OString sPropVal = rtl::math::doubleToString(fPropVal, rtl_math_StringFormat_F, 12, '.');
 385     auto nPropNameLength = strlen(pPropName);
 386     ensureSpace(nPropNameLength + sPropVal.getLength() + 8);
 387
 388     addCommaBeforeField();
 389
 390     *mPos = '"';
 391     ++mPos;
 392     memcpy(mPos, pPropName, nPropNameLength);
 393     mPos += nPropNameLength;
 394     memcpy(mPos, "\": ", 3);
 395     mPos += 3;
 396
 397     memcpy(mPos, sPropVal.getStr(), sPropVal.getLength());
 398     mPos += sPropVal.getLength();
 399
 400     validate();
 401 }
 402
 403 void JsonWriter::put(const char* pPropName, bool nPropVal)
 404 {
 405     auto nPropNameLength = strlen(pPropName);
 406     ensureSpace(nPropNameLength + 5 + 8);
 407
 408     addCommaBeforeField();
 409
 410     *mPos = '"';
 411     ++mPos;
 412     memcpy(mPos, pPropName, nPropNameLength);
 413     mPos += nPropNameLength;
 414     memcpy(mPos, "\": ", 3);
 415     mPos += 3;
 416
 417     const char* pVal;
 418     if (nPropVal)
 419         pVal = "true";
 420     else
 421         pVal = "false";
 422     memcpy(mPos, pVal, strlen(pVal));
 423     mPos += strlen(pVal);
 424
 425     validate();
 426 }
 427
 428 void JsonWriter::putSimpleValue(const OUString& rPropVal)
 429 {
 430     auto nWorstCasePropValLength = rPropVal.getLength() * 3;
 431     ensureSpace(nWorstCasePropValLength + 4);
 432
 433     addCommaBeforeField();
 434
 435     *mPos = '"';
 436     ++mPos;
 437
 438     writeEscapedOUString(rPropVal);
 439
 440     *mPos = '"';
 441     ++mPos;
 442
 443     validate();
 444 }
 445
 446 void JsonWriter::putRaw(std::string_view rRawBuf)
 447 {
 448     ensureSpace(rRawBuf.size() + 2);
 449
 450     addCommaBeforeField();
 451
 452     memcpy(mPos, rRawBuf.data(), rRawBuf.size());
 453     mPos += rRawBuf.size();
 454
 455     validate();
 456 }
 457
 458 void JsonWriter::addCommaBeforeField()
 459 {
 460     if (mbFirstFieldInNode)
 461         mbFirstFieldInNode = false;
 462     else
 463     {
 464         *mPos = ',';
 465         ++mPos;
 466         *mPos = ' ';
 467         ++mPos;
 468     }
 469 }
 470
 471 void JsonWriter::ensureSpace(int noMoreBytesRequired)
 472 {
 473     assert(mpBuffer && "already extracted data");
 474     int currentUsed = mPos - mpBuffer;
 475     if (currentUsed + noMoreBytesRequired >= mSpaceAllocated)
 476     {
 477         auto newSize = (currentUsed + noMoreBytesRequired) * 2;
 478         mpBuffer = static_cast<char*>(realloc(mpBuffer, newSize));
 479         mPos = mpBuffer + currentUsed;
 480         mSpaceAllocated = newSize;
 481
 482         addValidationMark();
 483     }
 484 }
 485
 486 /** Hands ownership of the underlying storage buffer to the caller,
 487   * after this no more document modifications may be written. */
 488 std::pair<char*, int> JsonWriter::extractDataImpl()
 489 {
 490     assert(mStartNodeCount == 0 && "did not close all nodes");
 491     assert(mpBuffer && "data already extracted");
 492     ensureSpace(2);
 493     // add closing brace
 494     *mPos = '}';
 495     ++mPos;
 496     // null-terminate
 497     *mPos = 0;
 498     const int sz = mPos - mpBuffer;
 499     mPos = nullptr;
 500     return { std::exchange(mpBuffer, nullptr), sz };
 501 }
 502
 503 OString JsonWriter::extractAsOString()
 504 {
 505     auto[pChar, sz] = extractDataImpl();
 506     OString ret(pChar, sz);
 507     free(pChar);
 508     return ret;
 509 }
 510
 511 std::string JsonWriter::extractAsStdString()
 512 {
 513     auto[pChar, sz] = extractDataImpl();
 514     std::string ret(pChar, sz);
 515     free(pChar);
 516     return ret;
 517 }
 518
 519 bool JsonWriter::isDataEquals(const std::string& s) const
 520 {
 521     return s.length() == static_cast<size_t>(mPos - mpBuffer)
 522            && memcmp(s.data(), mpBuffer, s.length()) == 0;
 523 }
 524
 525 } // namespace tools
 526 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */