{"id":381833,"date":"2024-06-29T03:54:21","date_gmt":"2024-06-29T03:54:21","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=381833"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=381833","title":{"rendered":"Even small projects have bugs, or how PVS-Studio checked Blend2D<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n

We often check large projects because it’s easier to find bugs there. What if we try PVS-Studio on a small project? In this article we analyze Blend2D \u2014 a library for vector 2D graphics. Let’s look at what we found.<\/p>\n

<\/p>\n

\"0894_Blend2d\/image1.png\"<\/p>\n

<\/p>\n

Introduction<\/h2>\n

<\/p>\n

It’s no secret that large projects have fascinating errors. It’s not just «the larger the codebase is \u2013 the more errors we can find». It’s also a known fact that the density of errors grows<\/a> along with the codebase. That’s why we love checking large projects \u2014 to treat you with a variety of «yummy» and tricky errors and typos. Besides, it’s always interesting to search through a huge project with lots of dependencies, legacy code, and other stuff.<\/p>\n

<\/p>\n

Today I’m moving away from this tradition. I decided to take a small project and see what PVS-Studio can find there. I chose Blend2D \u2014 branch master<\/em>, commit c484790<\/a>.<\/a><\/p>\n

<\/p>\n

Blend2D<\/h2>\n

<\/p>\n

Blend2D is a 2D vector graphics engine. This small library written in C++ contains about 70,000 lines of code:<\/p>\n

<\/p>\n

--------------------------------------------------------------------- Language           files          blank        comment           code --------------------------------------------------------------------- C++                   97          12924           9481          43372 C\/C++ Header         137           8305          12971          25225<\/code><\/pre>\n
  <\/p>\n
This library allows you to create 2D images. To achieve high performance, the library developers used multithreaded rendering and a self-written rasterizer. Blend2D provides C and C++ API. You can read more about the project and capabilities of this library on the website<\/a>. Now let’s proceed to the errors that PVS-Studio found in the Blend2D source code.<\/p>\n
  <\/p>\n
An always-false expression<\/h2>\n
  <\/p>\n
V547<\/a> Expression ‘h == 0’ is always false. jpegcodec.cpp 252<\/p>\n
  <\/p>\n
BLResult blJpegDecoderImplProcessMarker(....) noexcept {   uint32_t h = blMemReadU16uBE(p + 1);   \/\/ ....   if (h == 0)     return blTraceError(BL_ERROR_JPEG_UNSUPPORTED_FEATURE);   \/\/ ....   impl->delayedHeight = (h == 0); \/\/ <=   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
In this code fragment, the result of the blMemReadU16uBE<\/em> function call is assigned to the h<\/em> variable. Then if the h == 0<\/em> check is true, we exit from the function’s body. During initialization impl->delayedHeight<\/em>, the h<\/em> variable has non-zero value. Thus, impl->delayedHeight<\/em> is false<\/em>.<\/p>\n
  <\/p>\n
A typo in the function’s signature<\/h2>\n
  <\/p>\n
V557 [CERT-ARR30-C] Array overrun is possible. The ‘3’ index is pointing beyond array bound. geometry_p.h 552<\/p>\n
  <\/p>\n
static BL_INLINE bool blIsCubicFlat(const BLPoint p[3], double f) {   if (p[3] == p[0]) {     \/\/ ....   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
In the signature of the blIsCubicFlat<\/em> function, the p<\/em> variable is declared as an array of 3 elements. Then, p[3]<\/em> is calculated in the body of the blMemReadU16uBE<\/em> function.<\/p>\n
  <\/p>\n
Declaring the const BLPoint p[3]<\/em> argument in the function’s signature equals declaring const BLPoint *p<\/em>. The specified size is a hint to the developer. The compiler doesn’t use the size in any way. Thus, array index out of bounds happens only if we pass an array of 3 or fewer elements to the function. If blIsCubicFlat<\/em> receives an array of 4 elements or more, there is no array index out of bounds and the code works in a defined way. I looked at the blIsCubicFlat<\/em> function call<\/a> and realized that the array of 4 elements is passed to this function. This means that there’s a mistake in the function’s signature \u2014 a typo in the value of the array size.<\/p>\n
  <\/p>\n
An extra evaluation due to an incorrect operator<\/h2>\n
  <\/p>\n
V792 The ‘_isTagged’ function located to the right of the operator ‘&’ will be called regardless of the value of the left operand. Perhaps, it is better to use ‘&&’. style.h 209<\/p>\n
  <\/p>\n
BL_NODISCARD BL_INLINE bool isObject() const noexcept {   return (data.type > BL_STYLE_TYPE_SOLID) & _isTagged(); }<\/code><\/pre>\n
  <\/p>\n
Here the analyzer suggests using the && logical operator instead of bitwise &. The thing is, when we use bitwise &, both of its arguments are calculated regardless of what values are obtained. For example, if (data.type > BL_STYLE_TYPE_SOLID)<\/em> is false, bitwise & returns 0 for any value of the second argument. However, the _isTagged<\/em> function is called anyway.<\/p>\n
  <\/p>\n
If (data.type > BL_STYLE_TYPE_SOLID)<\/em> is false, then the result of the && logical operator is also 0, regardless of the second argument. Here the _isTagged<\/em> function is not called. <\/p>\n
  <\/p>\n
The only question is, do we want to call the _isTagged<\/em> function always or only when it is necessary to calculate the result? This function may have some side effects, which we may want to use regardless of the calculation. To answer this question, I looked at the _isTagged<\/em> function code:<\/p>\n
  <\/p>\n
BL_NODISCARD BL_INLINE bool _isTagged(uint32_t styleType) const noexcept {<\/code><\/pre>\n
  <\/p>\n
As you see from the function’s signature, _isTagged<\/em> has the const<\/em> modifier. This means that the function has no side effects.<\/p>\n
  <\/p>\n
Thus, using logical && instead of bitwise & in this code fragment allows us to avoid an unnecessary function call and reduces the program’s execution time.<\/p>\n
  <\/p>\n
A redundant check<\/h2>\n
  <\/p>\n
V595 [CERT-EXP12-C] The ‘_threadPool’ pointer was utilized before it was verified against nullptr. Check lines: 158, 164. rasterworkermanager.cpp 158<\/p>\n
  <\/p>\n
class BLRasterWorkerManager { public:   BLThreadPool* _threadPool;   uint32_t _workerCount;   \/\/ .... } \/\/ .... void BLRasterWorkerManager::reset() noexcept {   \/\/ ....   if (_workerCount) {     \/\/ ....     _threadPool->releaseThreads(_workerThreads, _workerCount);     _workerCount = 0;     \/\/ ....   }   if (_threadPool) {     _threadPool->release();     _threadPool = nullptr;   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
The _threadPool<\/em> pointer is dereferenced and then it’s checked for nullptr<\/em>. The question is: is it an error or just a redundant check? Let’s try to figure it out.<\/p>\n
  <\/p>\n
When I examined the code, I realized the check was indeed redundant. We can simplify the code a bit. The following invariant is executed for the BLRasterWorkerManage<\/em> class: the _threadPool<\/em> pointer is null only when the _workerCount<\/em> field equals 0.<\/p>\n
  <\/p>\n
Besides the reset<\/em> method, fields workerCount<\/em> and _threadPool<\/em> are modified in two places: in the constructor and in the init<\/em> method. Let’s start with the constructor:<\/p>\n
  <\/p>\n
BL_INLINE BLRasterWorkerManager() noexcept     : \/\/ ....       _threadPool(nullptr),       \/\/ ....       _workerCount(0),       \/\/ ....       {}<\/code><\/pre>\n
  <\/p>\n
Everything is easy here: we assign 0 to the _workerCount<\/em> field, and nullptr<\/em> to the _threadPool<\/em> pointer. Invariant is obviously executed.<\/p>\n
  <\/p>\n
Not so easy with the init<\/em> method:<\/p>\n
  <\/p>\n
BLResult BLRasterWorkerManager::init(....) noexcept {   \/\/ ....   uint32_t workerCount = threadCount - 1;   \/\/ ....   if (workerCount) {     \/\/ ....     BLThreadPool* threadPool = nullptr;     if (initFlags & BL_CONTEXT_CREATE_FLAG_ISOLATED_THREAD_POOL) {       threadPool = blThreadPoolCreate();       if (!threadPool)         return blTraceError(BL_ERROR_OUT_OF_MEMORY);     }     else {       threadPool = blThreadPoolGlobal();     }     \/\/ ....     uint32_t n = threadPool->acquireThreads(workerThreads,  workerCount, acquireThreadFlags, &reason);     \/\/ ....     if (!n) {       threadPool->release();       threadPool = nullptr;       \/\/ ....     }     \/\/ ....     _threadPool = threadPool;     \/\/ ....     _workerCount = n;   }   else {   \/\/ ....   } }<\/code><\/pre>\n
  <\/p>\n
First, we calculate the value of the workerCount<\/em> local variable. Don’t confuse it with the _workerCount<\/em> field! If the variable’s value is 0, then the else branch is executed. In this branch, both fields remain unchanged. So, we’ll look only at the case where workerCount<\/em> is not equal to 0 and the then branch is executed. In this case, first, the threadPool<\/em> pointer (not _threadPool<\/em>!) becomes equal to 0. Then, depending on a condition, this pointer is initialized by the result of calling either blThreadPoolCreate<\/em> or blThreadPoolGlobal<\/em>. If it’s the blThreadPoolCreate<\/em> function and it returns nullptr<\/em>, then the no-return blTraceError<\/em> function is called. We are not interested in the further execution. The blThreadPoolGlobal<\/em> function looks like this:<\/p>\n
  <\/p>\n
static BLWrap<BLInternalThreadPool> blGlobalThreadPool; BLThreadPool* blThreadPoolGlobal() noexcept { return &blGlobalThreadPool; }<\/code><\/pre>\n
  <\/p>\n
This means that the blThreadPoolGlobal<\/em> function returns a non-null pointer. Consequently, either we lose control over the code, or the threadPool<\/em> pointer is not null. Let’s go further:<\/p>\n
  <\/p>\n
uint32_t n = threadPool->acquireThreads(workerThreads, workerCount,  acquireThreadFlags, &reason);<\/code><\/pre>\n
  <\/p>\n
Here, the value of the threads acquired is written to the n<\/em> variable. The value may or may not be zero. <\/p>\n
  <\/p>\n
If n<\/em> equals 0, the threadPool<\/em> pointer is nulled. The _threadPool<\/em> pointer is also nulled, the _workerCount<\/em> field is assigned the value of the n<\/em> variable \u2014 0. As a result: _threadPool = nullptr, _workerCount = 0.<\/em> In this case, the invariant is true.<\/p>\n
  <\/p>\n
Now let’s assume n<\/em> is not 0. In this case, the threadPool<\/em> pointer remains non-null and its value is written to the _threadPool<\/em> pointer. The _workerCount<\/em> field is assigned non-zero value of n<\/em>. As a result: _threadPool<\/em> is not equal to nullptr; _workerCount<\/em> is not equal to 0.<\/em> In this case the invariant is also true.<\/p>\n
  <\/p>\n
So, the invariant is really true. We can use it and say that checks (_workerCount)<\/em> and (_threadPool)<\/em> are always both true or both false. So, we can simplify the code by combining two checks into one. Like that, for example:<\/p>\n
  <\/p>\n
void BLRasterWorkerManager::reset() noexcept {   \/\/ ....   if (_workerCount) {     assert(_threadPool);     for (uint32_t i = 0; i < _workerCount; i++)       _workDataStorage[i]->~BLRasterWorkData();     _threadPool->releaseThreads(_workerThreads, _workerCount);     _workerCount = 0;     _workerThreads = nullptr;     _workDataStorage = nullptr;     _threadPool->release();     _threadPool = nullptr;   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
Using an uninitialized variable<\/h2>\n
  <\/p>\n
V573 [CERT-EXP53-CPP] Uninitialized variable ‘n’ was used. The variable was used to initialize itself. pixelconverter.cpp 2210<\/p>\n
  <\/p>\n
static BLResult BL_CDECL bl_convert_multi_step(...., uint32_t w, ....) {   for (uint32_t y = h; y; y--) {       uint32_t i = w;        workOpt.origin.x = baseOriginX;       dstData = dstLine;       srcData = srcLine;        while (i) {         uint32_t n = blMin(n, intermediatePixelCount);          srcToIntermediate(&ctx->first, intermediateData, 0,                            srcData, srcStride, n, 1, nullptr);         intermediateToDst(&ctx->second, dstData, dstStride,                            intermediateData, 0, n, 1, &workOpt);          dstData += n * dstBytesPerPixel;         srcData += n * srcBytesPerPixel;         workOpt.origin.x += int(n);          i -= n;       } }<\/code><\/pre>\n
  <\/p>\n
The following line triggered the analyzer: <\/p>\n
  <\/p>\n
uint32_t n = blMin(n, intermediatePixelCount);<\/em>.<\/p>\n
  <\/p>\n
Agree, it’s quite strange to declare a variable and use its uninitialized value. Looks like the developer wanted to write something like this:<\/p>\n
  <\/p>\n
uint32_t n = blMin(i, intermediatePixelCount);<\/em>.<\/p>\n
  <\/p>\n
This looks better \u2014 the i<\/em> variable is modified in the loop and is also used in the condition of breaking the loop.<\/p>\n
  <\/p>\n
An always-true check<\/h2>\n
  <\/p>\n
V547<\/a> Expression ‘x >= 5’ is always true. pngcodec.cpp 588<\/p>\n
  <\/p>\n
static void blPngDeinterlaceBits(....) noexcept {   \/\/ ....   uint32_t x = w;   \/\/ ....   switch (n) {     case 2: {       \/\/ ....       if (x <= 4) break;       if (x >= 5) b = uint32_t(*d5++);       \/\/ ....     }   \/\/ ....   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
Let’s assume that the value of the n<\/em> variable is 2 and we go to the corresponding switch<\/em> branch. If the value of the x<\/em> variable is less than 5<\/em>, the loop breaks. This means that check x >= 5<\/em> is always true.<\/p>\n
  <\/p>\n
It’s hard to say where the error is. Maybe this check is redundant and we need to remove it. Maybe the developer intended to compare x<\/em> with another value. Here’s one of the possible fixes:<\/p>\n
  <\/p>\n
static void blPngDeinterlaceBits(....) noexcept {   ....   uint32_t x = w;   ....   switch (n) {     case 2: {       \/\/ ....       if (x <= 4) break;       b = uint32_t(*d5++);       \/\/ ....     }     \/\/ ....   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
A copy-paste error<\/h2>\n
  <\/p>\n
V524<\/a> It is odd that the body of ‘end’ function is fully equivalent to the body of ‘begin’ function. string.h 258<\/p>\n
  <\/p>\n
class BLString : public BLStringCore { public:   \/\/ ....   BL_NODISCARD   BL_INLINE const char* begin() const noexcept   {     return impl->data + impl->size;   }    BL_NODISCARD   BL_INLINE const char* end() const noexcept   {     return impl->data + impl->size;   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
Obviously, a copy-paste error. When a developer implemented the begin<\/em> method, they copied the end<\/em> method and forgot to change the method’s body. Corrected version:<\/p>\n
  <\/p>\n
BL_NODISCARD BL_INLINE const char* begin() const noexcept {   return impl->data; }<\/code><\/pre>\n
  <\/p>\n
I suppose the readers have a question: «Wait, how did it happen? We usually write code from top to bottom. Why do you claim that the end method was copied and renamed into begin, and not vice versa?» This question is quite logical, so I present a small investigation of this warning.<\/p>\n
  <\/p>\n
First, the BLString<\/em> has the data<\/em> method. It looks like this:<\/p>\n
  <\/p>\n
BL_NODISCARD BL_INLINE const char* data() const noexcept { return impl->data; }<\/code><\/pre>\n
  <\/p>\n
And look at how many times it’s used:<\/p>\n
  <\/p>\n
\"0894_Blend2d\/image3.png\"<\/p>\n
  <\/p>\n
At the same time the begin<\/em> method is not used at all:<\/p>\n
  <\/p>\n
\"0894_Blend2d\/image5.png\"<\/p>\n
  <\/p>\n
Second, I found the following comment before the begin<\/em> method:<\/p>\n
  <\/p>\n
\/\/! Returns a pointer to the beginning of string data (iterator compatibility)<\/code><\/pre>\n
  <\/p>\n
Now when we found all the evidence, let me tell you what happened.<\/p>\n
  <\/p>\n
The BLString<\/em> class had the data<\/em> and end<\/em> methods. Everything was great. But then the Blend2D developers thought about iterator compatibility.<\/em> In particular, they wanted to make the following fragment work:<\/p>\n
  <\/p>\n
BLString str; for( auto symb : str ) { .... }<\/code><\/pre>\n
  <\/p>\n
The BLString<\/em> class needed to have methods begin<\/em> and end<\/em>. So, the developers wrote the missing begin<\/em> method. It’s more logical to copy the data<\/em> method. It does the same thing as begin<\/em>. But when developers support iterator compatibility<\/em>, they don’t think about the data<\/em> method at all. This method has nothing to do with it. Developers think about the end<\/em> method. They need it for iterator compatibility<\/em>, and it’s already implemented. So why not copy it? They did copy it, they forgot to change the body, and they got an error.<\/p>\n
  <\/p>\n
What does it lead to? Most likely, the begin<\/em> method is not called directly, the data<\/em> method is used instead. At the same time, the range-based for<\/em> loop (the example above) still doesn’t work. The code is compiled but does not iterate through the string.<\/p>\n
  <\/p>\n
Another copy-paste error<\/h2>\n
  <\/p>\n
V523 The ‘then’ statement is equivalent to the ‘else’ statement. pixelconverter.cpp 1215<\/p>\n
  <\/p>\n
template<typename PixelAccess, bool AlwaysUnaligned> static BLResult BL_CDECL bl_convert_argb32_from_prgb_any(....) {   for (uint32_t y = h; y != 0; y--) {     if (!AlwaysUnaligned && blIsAligned(srcData, PixelAccess::kSize))     {       for (uint32_t i = w; i != 0; i--) {         uint32_t pix = PixelAccess::fetchA(srcData);         uint32_t r = (((pix >> rShift) & rMask) * rScale) >> 16;         uint32_t g = (((pix >> gShift) & gMask) * gScale) >> 8;         uint32_t b = (((pix >> bShift) & bMask) * bScale) >> 8;         uint32_t a = (((pix >> aShift) & aMask) * aScale) >> 24;          BLPixelOps::unpremultiply_rgb_8bit(r, g, b, a);         blMemWriteU32a(dstData, (a << 24) | (r << 16) | (g << 8) | b);          dstData += 4;         srcData += PixelAccess::kSize;       }     }     else {       for (uint32_t i = w; i != 0; i--) {         uint32_t pix = PixelAccess::fetchA(srcData);         uint32_t r = (((pix >> rShift) & rMask) * rScale) >> 16;         uint32_t g = (((pix >> gShift) & gMask) * gScale) >> 8;         uint32_t b = (((pix >> bShift) & bMask) * bScale) >> 8;         uint32_t a = (((pix >> aShift) & aMask) * aScale) >> 24;          BLPixelOps::unpremultiply_rgb_8bit(r, g, b, a);         blMemWriteU32a(dstData, (a << 24) | (r << 16) | (g << 8) | b);          dstData += 4;         srcData += PixelAccess::kSize;       }     }     \/\/ ....   } }<\/code><\/pre>\n
  <\/p>\n
Another example of a copy-paste error. In this code fragment, branches else<\/em> and then<\/em> are completely identical. Obviously, the developer forgot to change the code on one of the branches, but I can’t offer any fix here.<\/p>\n
  <\/p>\n
An idempotent loop<\/h2>\n
  <\/p>\n
V1044<\/a> Loop break conditions do not depend on the number of iterations. otcmap.cpp 59<\/p>\n
  <\/p>\n
#if defined(__GNUC__)   #define BL_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1)   #define BL_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) #else   #define BL_LIKELY(...) (__VA_ARGS__)   #define BL_UNLIKELY(...) (__VA_ARGS__) #endif .... static BLResult BL_CDECL mapTextToGlyphsFormat0(....) noexcept {   \/\/ ....   uint32_t* ptr = content;   uint32_t* end = content + count;   \/\/ ....   while (ptr != end) {     uint32_t codePoint = content[0];     uint32_t glyphId = codePoint < 256                          ? uint32_t(glyphIdArray[codePoint].value())                          : uint32_t(0);     content[0] = glyphId;     if (BL_UNLIKELY(glyphId == 0)) {       if (!undefinedCount)         state->undefinedFirst = (size_t)(ptr - content);       undefinedCount++;     }   }   \/\/ .... }<\/code><\/pre>\n
  <\/p>\n
This code fragment may cause looping. Variables ptr<\/em> and end<\/em> don’t change within the loop. If condition ptr != end<\/em> is true, we get an infinite loop. Looks like the developer forgot to add the ptr<\/em> pointer increment. We can fix the code like this:<\/p>\n
  <\/p>\n
while (ptr != end) {   uint32_t codePoint = content[0];   uint32_t glyphId = codePoint < 256                        ? uint32_t(glyphIdArray[codePoint].value())                        : uint32_t(0);   content[0] = glyphId;   if (BL_UNLIKELY(glyphId == 0)) {     if (!undefinedCount)       state->undefinedFirst = (size_t)(ptr - content);     undefinedCount++;   }   ++ptr; }<\/code><\/pre>\n
  <\/p>\n
The analyzer issued another warning for this loop:<\/p>\n
  <\/p>\n
V776<\/a> Potentially infinite loop. The variable in the loop exit condition ‘ptr != end’ does not change its value between iterations. otcmap.cpp 59<\/p>\n
  <\/p>\n
Conclusion<\/h2>\n
  <\/p>\n
Of course, this project doesn’t have as many errors as large projects with about a million code lines. But we expected that.<\/p>\n
  <\/p>\n
However, this project has some impressive errors. What does this mean?<\/p>\n
  <\/p>\n
First, even small projects have errors. Which means, we need to find them and fix them \ud83d\ude42<\/p>\n
  <\/p>\n
Second, a small codebase is not a guarantee that all errors will be found during code review. Sometimes developers miss an error after reading the code several times.<\/p>\n
  <\/p>\n
But static analysis tools don’t miss them. A static analyzer is ready to search for errors in code at any time of the day. It doesn’t need to rest. And most importantly \u2014 its all-seeing eye spies every typo in code!<\/p>\n
  <\/p>\n
If you are interested in static analysis and PVS-Studio \u2014 it’s high time to try it. Just download a free version<\/a> of the analyzer. Thank you for reading!<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/593161\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
\n
\n
\n
\n
We often check large projects because it’s easier to find bugs there. What if we try PVS-Studio on a small project? In this article we analyze Blend2D \u2014 a library for vector 2D graphics. Let’s look at what we found.<\/p>\n
  <\/p>\n
\"0894_Blend2d\/image1.png\"<\/p>\n
  <\/p>\n
Introduction<\/h2>\n
  <\/p>\n
It’s no secret that large projects have fascinating errors. It’s not just «the larger the codebase is \u2013 the more errors we can find». It’s also a known fact that the density of errors grows<\/a> along with the codebase. That’s why we love checking large projects \u2014 to treat you with a variety of «yummy» and tricky errors and typos. Besides, it’s always interesting to search through a huge project with lots of dependencies, legacy code, and other stuff.<\/p>\n
  <\/p>\n
Today I’m moving away from this tradition. I decided to take a small project and see what PVS-Studio can find there. I chose Blend2D \u2014 branch master<\/em>, commit c484790<\/a>.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-381833","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/381833","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=381833"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/381833\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=381833"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=381833"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=381833"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}