Update to latest.

.github/workflows/cpp-ci-serial-programs.yml

@@ -10,11 +10,25 @@ jobs:
       fail-fast: false
       matrix:
         os: [windows-2025, macos-13, ubuntu-24.04]
+        compiler: ['default', 'clang']
         qt_version: ['6.9.1']
         include:
-        - qt_version: '6.9.1'
-          qt_version_major: '6'
-          qt_modules: 'qtmultimedia qtserialport'
+          - qt_version: '6.9.1'
+            qt_version_major: '6'
+            qt_modules: 'qtmultimedia qtserialport'
+
+          - os: 'windows-2025'
+            compiler: 'clang'
+            cmake_additional_param: '-T ClangCL'
+
+          - os: 'ubuntu-24.04'
+            compiler: 'clang'
+            cmake_additional_param: '-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++'
+
+        exclude:
+          - os: 'macos-13'
+            compiler: 'clang'
+            # Excluded because macos default toolset is already clang
 
     steps:
     - uses: actions/checkout@v4
@@ -44,7 +58,7 @@ jobs:
         cd Arduino-Source/SerialPrograms
         mkdir bin
         cd bin
-        cmake .. -DQT_MAJOR:STRING=${{ matrix.qt_version_major }}
+        cmake .. -DQT_MAJOR:STRING=${{ matrix.qt_version_major }} ${{ matrix.cmake_additional_param }}
         cmake --build . --config Release --parallel 10
     - name: Copy resources
       if: startsWith(matrix.os, 'windows')
@@ -66,5 +80,5 @@ jobs:
     - uses: actions/upload-artifact@v4
       if: startsWith(matrix.os, 'windows')
       with:
-        name: Serial Programs for windows (${{ matrix.qt_version }})
+        name: Serial Programs (os=${{ matrix.os }} - compiler=${{ matrix.compiler }} - qt_version=${{ matrix.qt_version }})
         path: Output

ClientSource/Connection/MessageLogger.cpp

@@ -96,11 +96,6 @@ void SerialLogger::log(const std::string& msg, Color color){
         m_logger.log(msg, color);
     }
 }
-void SerialLogger::log(std::string msg){
-    if (ok_to_log()){
-        m_logger.log(msg, COLOR_DARKGREEN);
-    }
-}
 
 bool SerialLogger::ok_to_log(){
     WallClock now = current_time();

ClientSource/Connection/MessageLogger.h

@@ -17,7 +17,7 @@
 namespace PokemonAutomation{
 
 
-class MessageLogger : public MessageSniffer{
+class MessageLogger : public Logger, public MessageSniffer{
 public:
     MessageLogger(bool log_everything = false)
         : m_log_everything_owner(log_everything)
@@ -29,7 +29,6 @@ class MessageLogger : public MessageSniffer{
     {}
 
 
-//    virtual void log(std::string msg) override;
     virtual void on_send(const BotBaseMessage& message, bool is_retransmit) override;
     virtual void on_recv(const BotBaseMessage& message) override;
 
@@ -40,13 +39,12 @@ class MessageLogger : public MessageSniffer{
 
 
 
-class SerialLogger : public Logger, public MessageLogger{
+class SerialLogger : public MessageLogger{
 public:
     SerialLogger(Logger& logger, bool log_everything);
 
-    virtual void log(const char* msg, Color color = Color()) override;
-    virtual void log(const std::string& msg, Color color = Color()) override;
-    virtual void log(std::string msg) override;
+    virtual void log(const char* msg, Color color = COLOR_DARKGREEN) override;
+    virtual void log(const std::string& msg, Color color = COLOR_DARKGREEN) override;
 
 private:
     bool ok_to_log();

ClientSource/Connection/MessageSniffer.h

@@ -17,7 +17,6 @@ struct BotBaseMessage;
 
 class MessageSniffer{
 public:
-    virtual void log(std::string msg){}
     virtual void on_send(const BotBaseMessage& message, bool is_retransmit){}
     virtual void on_recv(const BotBaseMessage& message){}
 };

ClientSource/Connection/PABotBase.cpp

@@ -312,7 +312,7 @@ void PABotBase::process_ack_request(BotBaseMessage message){
 
     if constexpr (!variable_length){
         if (message.body.size() != sizeof(Params)){
-            m_sniffer->log("Ignoring message with invalid size.");
+            m_logger.log("Ignoring message with invalid size.");
             return;
         }
     }
@@ -324,14 +324,14 @@ void PABotBase::process_ack_request(BotBaseMessage message){
         WriteSpinLock lg(m_state_lock, "PABotBase::process_ack_request()");
 
         if (m_pending_requests.empty()){
-            m_sniffer->log("Unexpected request ack message: seqnum = " + std::to_string(seqnum));
+            m_logger.log("Unexpected request ack message: seqnum = " + std::to_string(seqnum));
             return;
         }
 
         uint64_t full_seqnum = infer_full_seqnum(m_pending_requests, seqnum);
         std::map<uint64_t, PendingRequest>::iterator iter = m_pending_requests.find(full_seqnum);
         if (iter == m_pending_requests.end()){
-            m_sniffer->log("Unexpected request ack message: seqnum = " + std::to_string(seqnum));
+            m_logger.log("Unexpected request ack message: seqnum = " + std::to_string(seqnum));
             return;
         }
         iter->second.sanitizer.check_usage();
@@ -357,10 +357,10 @@ void PABotBase::process_ack_request(BotBaseMessage message){
         }
         return;
     case AckState::ACKED:
-        m_sniffer->log("Duplicate request ack message: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Duplicate request ack message: seqnum = " + std::to_string(seqnum));
         return;
     case AckState::FINISHED:
-        m_sniffer->log("Request ack on command finish: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Request ack on command finish: seqnum = " + std::to_string(seqnum));
         return;
     }
 }
@@ -369,7 +369,7 @@ void PABotBase::process_ack_command(BotBaseMessage message){
     auto scope_check = m_sanitizer.check_scope();
 
     if (message.body.size() != sizeof(Params)){
-        m_sniffer->log("Ignoring message with invalid size.");
+        m_logger.log("Ignoring message with invalid size.");
         return;
     }
     const Params* params = (const Params*)message.body.c_str();
@@ -378,14 +378,14 @@ void PABotBase::process_ack_command(BotBaseMessage message){
     WriteSpinLock lg(m_state_lock, "PABotBase::process_ack_command()");
 
     if (m_pending_commands.empty()){
-        m_sniffer->log("Unexpected command ack message: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Unexpected command ack message: seqnum = " + std::to_string(seqnum));
         return;
     }
 
     uint64_t full_seqnum = infer_full_seqnum(m_pending_commands, seqnum);
     auto iter = m_pending_commands.find(full_seqnum);
     if (iter == m_pending_commands.end()){
-        m_sniffer->log("Unexpected command ack message: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Unexpected command ack message: seqnum = " + std::to_string(seqnum));
         return;
     }
     iter->second.sanitizer.check_usage();
@@ -399,10 +399,10 @@ void PABotBase::process_ack_command(BotBaseMessage message){
         iter->second.ack = std::move(message);
         return;
     case AckState::ACKED:
-        m_sniffer->log("Duplicate command ack message: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Duplicate command ack message: seqnum = " + std::to_string(seqnum));
         return;
     case AckState::FINISHED:
-        m_sniffer->log("Command ack on finished command: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Command ack on finished command: seqnum = " + std::to_string(seqnum));
         return;
     }
 }
@@ -411,7 +411,7 @@ void PABotBase::process_command_finished(BotBaseMessage message){
     auto scope_check = m_sanitizer.check_scope();
 
     if (message.body.size() != sizeof(Params)){
-        m_sniffer->log("Ignoring message with invalid size.");
+        m_logger.log("Ignoring message with invalid size.");
         return;
     }
     const Params* params = (const Params*)message.body.c_str();
@@ -437,7 +437,7 @@ void PABotBase::process_command_finished(BotBaseMessage message){
 #endif
 
     if (m_pending_commands.empty()){
-        m_sniffer->log(
+        m_logger.log(
             "Unexpected command finished message: seqnum = " + std::to_string(seqnum) +
             ", command_seqnum = " + std::to_string(command_seqnum)
         );
@@ -447,7 +447,7 @@ void PABotBase::process_command_finished(BotBaseMessage message){
     uint64_t full_seqnum = infer_full_seqnum(m_pending_commands, command_seqnum);
     auto iter = m_pending_commands.find(full_seqnum);
     if (iter == m_pending_commands.end()){
-        m_sniffer->log(
+        m_logger.log(
             "Unexpected command finished message: seqnum = " + std::to_string(seqnum) +
             ", command_seqnum = " + std::to_string(command_seqnum)
         );
@@ -466,7 +466,7 @@ void PABotBase::process_command_finished(BotBaseMessage message){
         m_cv.notify_all();
         return;
     case AckState::FINISHED:
-        m_sniffer->log("Duplicate command finish: seqnum = " + std::to_string(seqnum));
+        m_logger.log("Duplicate command finish: seqnum = " + std::to_string(seqnum));
         return;
     }
 }
@@ -494,7 +494,7 @@ void PABotBase::on_recv_message(BotBaseMessage message){
         return;
     case PABB_MSG_ERROR_INVALID_TYPE:{
         if (message.body.size() != sizeof(pabb_MsgInfoInvalidType)){
-            m_sniffer->log("Ignoring message with invalid size.");
+            m_logger.log("Ignoring message with invalid size.");
             return;
         }
         const pabb_MsgInfoInvalidType* params = (const pabb_MsgInfoInvalidType*)message.body.c_str();
@@ -509,7 +509,7 @@ void PABotBase::on_recv_message(BotBaseMessage message){
     }
     case PABB_MSG_ERROR_MISSED_REQUEST:{
         if (message.body.size() != sizeof(pabb_MsgInfoMissedRequest)){
-            m_sniffer->log("Ignoring message with invalid size.");
+            m_logger.log("Ignoring message with invalid size.");
             return;
         }
         const pabb_MsgInfoMissedRequest* params = (const pabb_MsgInfoMissedRequest*)message.body.c_str();

ClientSource/Connection/PABotBaseConnection.cpp

@@ -92,16 +92,16 @@ void PABotBaseConnection::push_error_byte(ErrorBatchType type, char byte){
     case ErrorBatchType::NO_ERROR_:
         break;
     case ErrorBatchType::ZERO_BYTES:
-        m_sniffer->log("Skipped " + std::to_string(m_current_error_batch.size()) + " zero byte(s).");
+        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " zero byte(s).");
         break;
     case ErrorBatchType::FF_BYTES:
-        m_sniffer->log("Skipped " + std::to_string(m_current_error_batch.size()) + " 0xff byte(s).");
+        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " 0xff byte(s).");
         break;
     case ErrorBatchType::ASCII_BYTES:
-        m_sniffer->log("Received possible ASCII: " + m_current_error_batch);
+        m_logger.log("Received possible ASCII: " + m_current_error_batch);
         break;
     case ErrorBatchType::OTHER:
-//        m_sniffer->log("Skipped " + std::to_string(m_current_error_batch.size()) + " invalid length byte(s).");
+//        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " invalid length byte(s).");
         break;
     }
 
@@ -119,7 +119,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
         uint8_t length = ~m_recv_buffer[0];
 
         if (m_recv_buffer[0] == 0){
-//            m_sniffer->log("Skipping zero byte.");
+//            m_logger.log("Skipping zero byte.");
             push_error_byte(ErrorBatchType::ZERO_BYTES, 0);
             m_recv_buffer.pop_front();
             continue;
@@ -130,7 +130,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
             if (length == 0){
                 push_error_byte(ErrorBatchType::FF_BYTES, ~length);
             }else{
-                m_sniffer->log("Message is too short: bytes = " + std::to_string(length));
+                m_logger.log("Message is too short: bytes = " + std::to_string(length));
                 push_error_byte(ErrorBatchType::OTHER, ~length);
             }
             m_recv_buffer.pop_front();
@@ -143,7 +143,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
 //            std::string text = ascii < 32
 //                ? ", ascii = " + std::to_string(ascii)
 //                : std::string(", char = ") + ascii;
-//            m_sniffer->log("Message is too long: bytes = " + std::to_string(length) + text);
+//            m_logger.log("Message is too long: bytes = " + std::to_string(length) + text);
             push_error_byte(ErrorBatchType::ASCII_BYTES, ~length);
             m_recv_buffer.pop_front();
             continue;
@@ -170,7 +170,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
             //  Compare
 //            std::cout << checksumA << " / " << checksumE << std::endl;
             if (checksumA != checksumE){
-                m_sniffer->log("Invalid Checksum: bytes = " + std::to_string(length));
+                m_logger.log("Invalid Checksum: bytes = " + std::to_string(length));
 //                std::cout << checksumA << " / " << checksumE << std::endl;
 //                log(message_to_string(message[1], &message[2], length - PABB_PROTOCOL_OVERHEAD));
                 m_recv_buffer.pop_front();

ClientSource/Connection/SerialConnectionWinAPI.h

@@ -44,7 +44,7 @@ class SerialConnection : public StreamConnection{
             throw ConnectionException(nullptr, "Unable to open serial connection (" + name + "). Error = " + std::to_string(error));
         }
 
-        DCB serial_params{0};
+        DCB serial_params{};
         serial_params.DCBlength = sizeof(serial_params);
 
         if (!GetCommState(m_handle, &serial_params)){
@@ -67,7 +67,7 @@ class SerialConnection : public StreamConnection{
         }
 
 #if 1
-        COMMTIMEOUTS timeouts{0};
+        COMMTIMEOUTS timeouts{};
         if (!GetCommTimeouts(m_handle, &timeouts)){
             DWORD error = GetLastError();
             CloseHandle(m_handle);

Common/Cpp/CancellableScope.h

@@ -111,7 +111,7 @@ class CancellableScope : public Cancellable{
 public:
     virtual ~CancellableScope() override;
 
-    virtual bool cancel(std::exception_ptr exception) noexcept override;
+    virtual bool cancel(std::exception_ptr exception = nullptr) noexcept override;
 
     void wait_for(std::chrono::milliseconds duration);
     void wait_until(WallClock stop);