format

* format

* Minor test fixes

* enable checking cpp format in ci

1 files changed, 82 insertions, 61 deletions

diff --git a/source/core/slang-riff.cpp b/source/core/slang-riff.cpp
index 83693433e..94cd2038e 100644
--- a/source/core/slang-riff.cpp
+++ b/source/core/slang-riff.cpp
@@ -1,19 +1,21 @@
 #include "slang-riff.h"
 
 #include "slang-com-helper.h"
-
 #include "slang-hex-dump-util.h"
 
 namespace Slang
 {
 
-/* static */int64_t RiffUtil::calcChunkTotalSize(const RiffHeader& chunk)
+/* static */ int64_t RiffUtil::calcChunkTotalSize(const RiffHeader& chunk)
 {
     size_t size = chunk.size + sizeof(RiffHeader);
     return getPadSize(size);
 }
 
-/* static */SlangResult RiffUtil::skip(const RiffHeader& chunk, Stream* stream, int64_t* remainingBytesInOut)
+/* static */ SlangResult RiffUtil::skip(
+    const RiffHeader& chunk,
+    Stream* stream,
+    int64_t* remainingBytesInOut)
 {
     int64_t chunkSize = calcChunkTotalSize(chunk);
     if (remainingBytesInOut)
@@ -26,7 +28,7 @@ namespace Slang
     return SLANG_OK;
 }
 
-/* static */SlangResult RiffUtil::readChunk(Stream* stream, RiffHeader& outChunk)
+/* static */ SlangResult RiffUtil::readChunk(Stream* stream, RiffHeader& outChunk)
 {
     size_t readBytes;
     SLANG_RETURN_ON_FAIL(stream->read(&outChunk, sizeof(RiffHeader), readBytes));
@@ -34,7 +36,12 @@ namespace Slang
     return (readBytes == sizeof(RiffHeader)) ? SLANG_OK : SLANG_FAIL;
 }
 
-/* static */SlangResult RiffUtil::writeData(const RiffHeader* header, size_t headerSize, const void* payload, size_t payloadSize, Stream* out)
+/* static */ SlangResult RiffUtil::writeData(
+    const RiffHeader* header,
+    size_t headerSize,
+    const void* payload,
+    size_t payloadSize,
+    Stream* out)
 {
     SLANG_ASSERT(uint64_t(payloadSize) <= uint64_t(0xfffffffff));
     SLANG_ASSERT(headerSize >= sizeof(RiffHeader));
@@ -62,14 +69,18 @@ namespace Slang
     size_t padSize = getPadSize(payloadSize);
     if (padSize - payloadSize)
     {
-        uint8_t end[kRiffPadSize] = { 0 };
+        uint8_t end[kRiffPadSize] = {0};
         SLANG_RETURN_ON_FAIL(out->write(end, padSize - payloadSize));
     }
-    
+
     return SLANG_OK;
 }
 
-/* static */SlangResult RiffUtil::readPayload(Stream* stream, size_t size, void* outData, size_t& outReadSize)
+/* static */ SlangResult RiffUtil::readPayload(
+    Stream* stream,
+    size_t size,
+    void* outData,
+    size_t& outReadSize)
 {
     outReadSize = 0;
 
@@ -85,7 +96,11 @@ namespace Slang
     return SLANG_OK;
 }
 
-/* static */SlangResult RiffUtil::readData(Stream* stream, RiffHeader* outHeader, size_t headerSize, List<uint8_t>& data)
+/* static */ SlangResult RiffUtil::readData(
+    Stream* stream,
+    RiffHeader* outHeader,
+    size_t headerSize,
+    List<uint8_t>& data)
 {
     RiffHeader chunk;
     SLANG_RETURN_ON_FAIL(readChunk(stream, chunk));
@@ -101,14 +116,14 @@ namespace Slang
     {
         SLANG_RETURN_ON_FAIL(stream->readExactly(outHeader + 1, headerSize - sizeof(RiffHeader)));
     }
- 
+
     const size_t payloadSize = chunk.size - (headerSize - sizeof(RiffHeader));
     size_t readSize;
     data.setCount(payloadSize);
     return readPayload(stream, payloadSize, data.getBuffer(), readSize);
 }
 
-/* static */SlangResult RiffUtil::readHeader(Stream* stream, RiffListHeader& outHeader)
+/* static */ SlangResult RiffUtil::readHeader(Stream* stream, RiffListHeader& outHeader)
 {
     // Need to read the chunk header
     SLANG_RETURN_ON_FAIL(readChunk(stream, outHeader.chunk));
@@ -117,13 +132,15 @@ namespace Slang
     if (isListType(outHeader.chunk.type))
     {
         // Read the sub type
-        SLANG_RETURN_ON_FAIL(stream->readExactly(&outHeader.subType, sizeof(RiffListHeader) - sizeof(RiffHeader)));
+        SLANG_RETURN_ON_FAIL(
+            stream->readExactly(&outHeader.subType, sizeof(RiffListHeader) - sizeof(RiffHeader)));
     }
 
     return SLANG_OK;
 }
 
-namespace { // anonymous
+namespace
+{ // anonymous
 
 struct DumpVisitor : public RiffContainer::Visitor
 {
@@ -167,10 +184,8 @@ struct DumpVisitor : public RiffContainer::Visitor
         return SLANG_OK;
     }
 
-    DumpVisitor(WriterHelper writer, Chunk* rootChunk) :
-        m_writer(writer),
-        m_indent(0),
-        m_rootChunk(rootChunk)
+    DumpVisitor(WriterHelper writer, Chunk* rootChunk)
+        : m_writer(writer), m_indent(0), m_rootChunk(rootChunk)
     {
     }
 
@@ -199,15 +214,18 @@ struct DumpVisitor : public RiffContainer::Visitor
     WriterHelper m_writer;
 };
 
-}
+} // namespace
 
-/* static */void RiffUtil::dump(RiffContainer::Chunk* chunk, WriterHelper writer)
+/* static */ void RiffUtil::dump(RiffContainer::Chunk* chunk, WriterHelper writer)
 {
     DumpVisitor visitor(writer, chunk);
     chunk->visit(&visitor);
 }
 
-/* static */SlangResult RiffUtil::write(RiffContainer::ListChunk* list, bool isRoot, Stream* stream)
+/* static */ SlangResult RiffUtil::write(
+    RiffContainer::ListChunk* list,
+    bool isRoot,
+    Stream* stream)
 {
     RiffListHeader listHeader;
 
@@ -218,20 +236,20 @@ struct DumpVisitor : public RiffContainer::Visitor
     // Write the header
     SLANG_RETURN_ON_FAIL(stream->write(&listHeader, sizeof(listHeader)));
 
-        // Write the contained chunks
+    // Write the contained chunks
     Chunk* chunk = list->m_containedChunks;
     while (chunk)
     {
         switch (chunk->m_kind)
         {
-            case Chunk::Kind::List:
+        case Chunk::Kind::List:
             {
                 auto listChunk = static_cast<ListChunk*>(chunk);
                 // It's a container
                 SLANG_RETURN_ON_FAIL(write(listChunk, false, stream));
                 break;
             }
-            case Chunk::Kind::Data:
+        case Chunk::Kind::Data:
             {
                 auto dataChunk = static_cast<DataChunk*>(chunk);
 
@@ -252,30 +270,31 @@ struct DumpVisitor : public RiffContainer::Visitor
                 }
 
                 // Need to write for alignment
-                const size_t remainingSize = getPadSize(dataChunk->m_payloadSize) - dataChunk->m_payloadSize;
+                const size_t remainingSize =
+                    getPadSize(dataChunk->m_payloadSize) - dataChunk->m_payloadSize;
 
                 if (remainingSize)
                 {
-                    static const uint8_t trailing[kRiffPadSize] = { 0 };
+                    static const uint8_t trailing[kRiffPadSize] = {0};
                     SLANG_RETURN_ON_FAIL(stream->write(trailing, remainingSize));
                 }
             }
-            default: break;
+        default: break;
         }
 
         // Next
         chunk = chunk->m_next;
     }
-    
+
     return SLANG_OK;
 }
 
-/* static */SlangResult RiffUtil::write(RiffContainer* container, Stream* stream)
+/* static */ SlangResult RiffUtil::write(RiffContainer* container, Stream* stream)
 {
     return write(container->getRoot(), true, stream);
 }
 
-/* static */SlangResult RiffUtil::read(Stream* stream, RiffContainer& outContainer)
+/* static */ SlangResult RiffUtil::read(Stream* stream, RiffContainer& outContainer)
 {
     typedef RiffContainer::ScopeChunk ScopeChunk;
     outContainer.reset();
@@ -333,7 +352,7 @@ struct DumpVisitor : public RiffContainer::Visitor
                 const size_t padSize = getPadSize(header.chunk.size);
 
                 // Subtract the size of this chunk from remaining of the current chunk
-                remaining -= sizeof(RiffHeader) + padSize;                
+                remaining -= sizeof(RiffHeader) + padSize;
                 // Push it, for when we hit the end
                 remainingStack.add(remaining);
 
@@ -347,11 +366,12 @@ struct DumpVisitor : public RiffContainer::Visitor
             {
                 ScopeChunk scopeChunk(&outContainer, Chunk::Kind::Data, header.chunk.type);
                 RiffContainer::Data* data = outContainer.addData();
-                
+
                 outContainer.setPayload(data, nullptr, header.chunk.size);
 
                 size_t readSize;
-                SLANG_RETURN_ON_FAIL(readPayload(stream, header.chunk.size, data->getPayload(), readSize));
+                SLANG_RETURN_ON_FAIL(
+                    readPayload(stream, header.chunk.size, data->getPayload(), readSize));
 
                 // All read sizes must end up aligned
                 SLANG_ASSERT((readSize & kRiffPadMask) == 0);
@@ -371,11 +391,11 @@ SlangResult RiffContainer::Chunk::visit(Visitor* visitor)
 {
     switch (m_kind)
     {
-        case Kind::Data:
+    case Kind::Data:
         {
             return visitor->handleData(static_cast<DataChunk*>(this));
         }
-        case Kind::List:
+    case Kind::List:
         {
             auto list = static_cast<ListChunk*>(this);
             SLANG_RETURN_ON_FAIL(visitor->enterList(list));
@@ -391,7 +411,7 @@ SlangResult RiffContainer::Chunk::visit(Visitor* visitor)
             SLANG_RETURN_ON_FAIL(visitor->leaveList(list));
             return SLANG_OK;
         }
-        default: return SLANG_FAIL;
+    default: return SLANG_FAIL;
     }
 }
 
@@ -399,11 +419,11 @@ SlangResult RiffContainer::Chunk::visitPreOrder(VisitorCallback callback, void*
 {
     switch (m_kind)
     {
-        case Kind::Data:
+    case Kind::Data:
         {
             return callback(this, data);
         }
-        case Kind::List:
+    case Kind::List:
         {
             auto list = static_cast<ListChunk*>(this);
             // Do this containing node first
@@ -418,7 +438,7 @@ SlangResult RiffContainer::Chunk::visitPreOrder(VisitorCallback callback, void*
             }
             return SLANG_OK;
         }
-        default: return SLANG_FAIL;
+    default: return SLANG_FAIL;
     }
 }
 
@@ -426,11 +446,11 @@ SlangResult RiffContainer::Chunk::visitPostOrder(VisitorCallback callback, void*
 {
     switch (m_kind)
     {
-        case Kind::Data:
+    case Kind::Data:
         {
             return callback(this, data);
         }
-        case Kind::List:
+    case Kind::List:
         {
             auto list = static_cast<ListChunk*>(this);
 
@@ -445,7 +465,7 @@ SlangResult RiffContainer::Chunk::visitPostOrder(VisitorCallback callback, void*
             SLANG_RETURN_ON_FAIL(callback(this, data));
             return SLANG_OK;
         }
-        default: return SLANG_FAIL;
+    default: return SLANG_FAIL;
     }
 }
 
@@ -453,15 +473,15 @@ size_t RiffContainer::Chunk::calcPayloadSize()
 {
     switch (m_kind)
     {
-        case Kind::Data:        return static_cast<DataChunk*>(this)->calcPayloadSize();
-        case Kind::List:        return static_cast<ListChunk*>(this)->calcPayloadSize();
-        default: return 0;
+    case Kind::Data: return static_cast<DataChunk*>(this)->calcPayloadSize();
+    case Kind::List: return static_cast<ListChunk*>(this)->calcPayloadSize();
+    default:         return 0;
     }
 }
 
 RiffContainer::Data* RiffContainer::Chunk::getSingleData() const
 {
-    return (m_kind == Kind::Data) ? static_cast<const DataChunk*>(this)->getSingleData(): nullptr;
+    return (m_kind == Kind::Data) ? static_cast<const DataChunk*>(this)->getSingleData() : nullptr;
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!! RiffContainer::ListChunk !!!!!!!!!!!!!!!!!!!!!!
@@ -582,7 +602,7 @@ static RiffContainer::ListChunk* _findListRec(RiffContainer::ListChunk* list, Fo
     return nullptr;
 }
 
-/* static */RiffContainer::ListChunk* RiffContainer::ListChunk::findListRec(FourCC subType)
+/* static */ RiffContainer::ListChunk* RiffContainer::ListChunk::findListRec(FourCC subType)
 {
     return (getSubType() == subType) ? this : _findListRec(this, subType);
 }
@@ -683,8 +703,8 @@ bool RiffContainer::DataChunk::isEqual(const void* inData, size_t count) const
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! RiffContainer !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-RiffContainer::RiffContainer() :
-    m_arena(4096)
+RiffContainer::RiffContainer()
+    : m_arena(4096)
 {
     m_rootList = nullptr;
     m_listChunk = nullptr;
@@ -723,7 +743,8 @@ void RiffContainer::_addChunk(Chunk* chunk)
     if (m_listChunk)
     {
         chunk->m_parent = m_listChunk;
-        Chunk*& next = m_listChunk->m_endChunk ? m_listChunk->m_endChunk->m_next : m_listChunk->m_containedChunks;
+        Chunk*& next = m_listChunk->m_endChunk ? m_listChunk->m_endChunk->m_next
+                                               : m_listChunk->m_containedChunks;
         SLANG_ASSERT(next == nullptr);
         next = chunk;
         m_listChunk->m_endChunk = chunk;
@@ -736,9 +757,10 @@ void RiffContainer::startChunk(Chunk::Kind kind, FourCC fourCC)
 
     switch (kind)
     {
-        case Chunk::Kind::Data:
+    case Chunk::Kind::Data:
         {
-            // We can only start a data chunk if we are in a container, and we can't already be in data chunk
+            // We can only start a data chunk if we are in a container, and we can't already be in
+            // data chunk
             SLANG_ASSERT(m_listChunk && m_dataChunk == nullptr);
 
             DataChunk* chunk = _newDataChunk(fourCC);
@@ -746,7 +768,7 @@ void RiffContainer::startChunk(Chunk::Kind kind, FourCC fourCC)
             m_dataChunk = chunk;
             break;
         }
-        case Chunk::Kind::List:
+    case Chunk::Kind::List:
         {
             // We can't be in a data chunk
             SLANG_ASSERT(m_dataChunk == nullptr);
@@ -771,7 +793,7 @@ void RiffContainer::endChunk()
 {
     size_t chunkPayloadSize;
 
-    // The chunk we are popping 
+    // The chunk we are popping
     // Only keep track of this in debug builds
     [[maybe_unused]] Chunk* chunk = nullptr;
 
@@ -782,7 +804,7 @@ void RiffContainer::endChunk()
 
         parent = m_dataChunk->m_parent;
         chunkPayloadSize = m_dataChunk->m_payloadSize;
-        
+
         m_dataChunk = nullptr;
     }
     else
@@ -824,7 +846,7 @@ void RiffContainer::setPayload(Data* data, const void* payload, size_t size)
 
     // Add current chunks data
     m_dataChunk->m_payloadSize += size;
-    
+
     data->m_ownership = Ownership::Arena;
     data->m_size = size;
 
@@ -901,7 +923,7 @@ RiffContainer::Data* RiffContainer::makeSingleData(DataChunk* dataChunk)
 
     {
         Data* data = dataChunk->m_dataList;
-        
+
         // Okay lets combine all into one block
         const size_t payloadSize = dataChunk->calcPayloadSize();
 
@@ -932,7 +954,7 @@ void RiffContainer::write(const void* inData, size_t size)
     {
         uint8_t* end = ((uint8_t*)endData->m_payload) + endData->m_size;
         // See if can just add to end of current data
-        if ( end == m_arena.getCursor() && m_arena.allocateCurrentUnaligned(size))
+        if (end == m_arena.getCursor() && m_arena.allocateCurrentUnaligned(size))
         {
             ::memcpy(end, inData, size);
             endData->m_size += size;
@@ -953,7 +975,7 @@ static SlangResult _isChunkOk(RiffContainer::Chunk* chunk, void* data)
     return chunk->calcPayloadSize() == chunk->m_payloadSize ? SLANG_OK : SLANG_FAIL;
 }
 
-/* static */bool RiffContainer::isChunkOk(Chunk* chunk)
+/* static */ bool RiffContainer::isChunkOk(Chunk* chunk)
 {
     return SLANG_SUCCEEDED(chunk->visitPostOrder(&_isChunkOk, nullptr));
 }
@@ -965,11 +987,10 @@ static SlangResult _calcAndSetSize(RiffContainer::Chunk* chunk, void* data)
     return SLANG_OK;
 }
 
-/* static */void RiffContainer::calcAndSetSize(Chunk* chunk)
+/* static */ void RiffContainer::calcAndSetSize(Chunk* chunk)
 {
     chunk->visitPostOrder(&_calcAndSetSize, nullptr);
 }
 
 
-
-}
+} // namespace Slang