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