Improve ASSERT macro, fix linux file paths in Taskfile and hopefully fix the windows release

.github/workflows/linter-workflow.yaml

@@ -21,7 +21,9 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Get Package Dependencies
-        run: sudo apt install clang-format clang-tidy
+        run: |
+          sudo apt install clang-format clang-tidy
+          clang-format -version
 
       - name: Check Clang-Formatting
         run: |

.github/workflows/windows-workflow.yaml

@@ -85,7 +85,7 @@ jobs:
         run: |
           mkdir -p ./ci-artifacts/out
           ./.github/scripts/releases/extract_build_windows.sh ./ci-artifacts/out ./
-          7z a -tzip ./ci-artifacts/windows.zip ./ci-artfacts/out
+          7z a -tzip ./ci-artifacts/windows.zip ./ci-artifacts/out
 
       - name: Upload Assets and Potential Publish Release
         if: github.repository == 'open-goal/jak-project' && startsWith(github.ref, 'refs/tags/') && matrix.compiler == 'clang'

Taskfile.yml

@@ -13,27 +13,27 @@ tasks:
       - '{{.DECOMP_BIN_RELEASE_DIR}}/decompiler "./decompiler/config/jak1_ntsc_black_label.jsonc" "./iso_data" "./decompiler_out" "decompile_code=false"'
   boot-game:
     preconditions:
-      - sh: test -f {{.DECOMP_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
+      - sh: test -f {{.GK_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
         msg: "Couldn't locate runtime executable -- Have you compiled in release mode?"
     cmds:
       - "{{.GK_BIN_RELEASE_DIR}}/gk -boot -fakeiso -debug -v"
   run-game:
     preconditions:
-      - sh: test -f {{.DECOMP_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
+      - sh: test -f {{.GK_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
         msg: "Couldn't locate runtime executable -- Have you compiled in release mode?"
     cmds:
       - "{{.GK_BIN_RELEASE_DIR}}/gk -fakeiso -debug -v"
   run-game-quiet:
     preconditions:
-      - sh: test -f {{.DECOMP_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
+      - sh: test -f {{.GK_BIN_RELEASE_DIR}}/gk{{.EXE_FILE_EXTENSION}}
         msg: "Couldn't locate runtime executable -- Have you compiled in release mode?"
     cmds:
       - "{{.GK_BIN_RELEASE_DIR}}/gk -fakeiso"
   repl:
     env:
       OPENGOAL_DECOMP_DIR: "jak1/"
     preconditions:
-      - sh: test -f {{.DECOMP_BIN_RELEASE_DIR}}/goalc{{.EXE_FILE_EXTENSION}}
+      - sh: test -f {{.GOALC_BIN_RELEASE_DIR}}/goalc{{.EXE_FILE_EXTENSION}}
         msg: "Couldn't locate compiler executable -- Have you compiled in release mode?"
     cmds:
       - "{{.GOALC_BIN_RELEASE_DIR}}/goalc"

common/audio/audio_formats.cpp

@@ -289,8 +289,7 @@ void test_encode_adpcm(const std::vector<s16>& samples,
       for (int i = 0; i < 5; i++) {
         fmt::print(" [{}] {} {}\n", i, filter_errors[i], filter_shifts[i]);
       }
-      fmt::print("prev: {} {}\n", prev_block_samples[0], prev_block_samples[1]);
-      ASSERT(false);
+      ASSERT_MSG(false, fmt::format("prev: {} {}", prev_block_samples[0], prev_block_samples[1]));
     }
 
     prev_block_samples[0] = samples.at(block_idx * 28 + 27);

common/custom_data/TFrag3Data.cpp

@@ -235,10 +235,9 @@ void Texture::serialize(Serializer& ser) {
 
 void Level::serialize(Serializer& ser) {
   ser.from_ptr(&version);
-  if (ser.is_loading() && version != TFRAG3_VERSION) {
-    fmt::print("version mismatch when loading tfrag3 data. Got {}, expected {}\n", version,
-               TFRAG3_VERSION);
-    ASSERT(false);
+  if (true) {
+    ASSERT_MSG(false, fmt::format("version mismatch when loading tfrag3 data. Got {}, expected {}",
+                                  version, TFRAG3_VERSION));
   }
 
   ser.from_str(&level_name);
@@ -285,9 +284,9 @@ void Level::serialize(Serializer& ser) {
 
   ser.from_ptr(&version2);
   if (ser.is_loading() && version2 != TFRAG3_VERSION) {
-    fmt::print("version mismatch when loading tfrag3 data (at end). Got {}, expected {}\n",
-               version2, TFRAG3_VERSION);
-    ASSERT(false);
+    ASSERT_MSG(false, fmt::format(
+                          "version mismatch when loading tfrag3 data (at end). Got {}, expected {}",
+                          version2, TFRAG3_VERSION));
   }
 }
 

common/dma/dma.cpp

@@ -115,10 +115,8 @@ std::string VifCode::print() {
     }
 
     default:
-      fmt::print("Unhandled vif code {}\n", (int)kind);
-
       result = "???";
-      ASSERT(false);
+      ASSERT_MSG(false, fmt::format("Unhandled vif code {}", (int)kind));
       break;
   }
   // TODO: the rest of the VIF code.

common/dma/dma.h

@@ -91,8 +91,7 @@ inline void emulate_dma(const void* source_base, void* dest_base, u32 tadr, u32
         // does this transfer anything in TTE???
         return;
       default:
-        printf("bad tag: %d\n", (int)tag.kind);
-        ASSERT(false);
+        ASSERT_MSG(false, fmt::format("bad tag: {}", (int)tag.kind));
     }
   }
 }

common/util/Assert.cpp

@@ -3,7 +3,18 @@
 
 #include "Assert.h"
 
-void private_assert_failed(const char* expr, const char* file, int line, const char* function) {
-  fprintf(stderr, "%s:%d: Assertion failed: %s\nFunction: %s\n", file, line, expr, function);
+void private_assert_failed(const char* expr,
+                           const char* file,
+                           int line,
+                           const char* function,
+                           const char* msg) {
+  if ((msg != NULL) && (msg[0] == '\0')) {
+    fprintf(stderr, "Assertion failed: '%s'\n\tSource: %s:%d\n\tFunction: %s\n", expr, file, line,
+            function);
+  } else {
+    fprintf(stderr, "Assertion failed: '%s'\n\tMessage: %s\n\tSource: %s:%d\n\tFunction: %s\n",
+            expr, msg, file, line, function);
+  }
+  fflush(stdout);  // ensure any stdout logs are flushed before we terminate
   abort();
 }

common/util/Assert.h

@@ -3,16 +3,23 @@
  * Custom ASSERT macro
  */
 
+#include "third-party/fmt/core.h"
+
 #pragma once
 
 [[noreturn]] void private_assert_failed(const char* expr,
                                         const char* file,
                                         int line,
-                                        const char* function);
+                                        const char* function,
+                                        const char* msg = "");
 
 #ifdef _WIN32
 #define __PRETTY_FUNCTION__ __FUNCSIG__
 #endif
 
 #define ASSERT(EX) \
   (void)((EX) || (private_assert_failed(#EX, __FILE__, __LINE__, __PRETTY_FUNCTION__), 0))
+
+#define ASSERT_MSG(EXPR, STR) \
+  (void)((EXPR) ||            \
+         (private_assert_failed(#EXPR, __FILE__, __LINE__, __PRETTY_FUNCTION__, STR.c_str()), 0))

common/util/FileUtil.cpp

@@ -425,8 +425,7 @@ void MakeISOName(char* dst, const char* src) {
 
 void assert_file_exists(const char* path, const char* error_message) {
   if (!std::filesystem::exists(path)) {
-    fprintf(stderr, "File %s was not found: %s\n", path, error_message);
-    ASSERT(false);
+    ASSERT_MSG(false, fmt::format("File {} was not found: {}", path, error_message));
   }
 }
 

common/util/SmallVector.h

@@ -61,8 +61,12 @@ class SmallVector {
   typename std::aligned_storage<sizeof(T), alignof(T)>::type m_inline[inline_elt_count];
 
   // get a T* at the beginning of our inline storage.
-  constexpr const T* inline_begin() const { return launder(reinterpret_cast<const T*>(m_inline)); }
-  constexpr T* inline_begin() { return launder(reinterpret_cast<T*>(m_inline)); }
+  constexpr const T* inline_begin() const {
+    return launder(reinterpret_cast<const T*>(m_inline));
+  }
+  constexpr T* inline_begin() {
+    return launder(reinterpret_cast<T*>(m_inline));
+  }
 
   // regardless of our storage mode, these hold the beginning and end of the storage.
   // by default, they are initialized to the inline storage.
@@ -86,7 +90,9 @@ class SmallVector {
   /*!
    * Free heap storage, without calling destructors of objects.
    */
-  void free_heap_storage(T* ptr) { delete[] launder(reinterpret_cast<uint8_t*>(ptr)); }
+  void free_heap_storage(T* ptr) {
+    delete[] launder(reinterpret_cast<uint8_t*>(ptr));
+  }
 
   /*!
    * Set the current storage to the inline memory.
@@ -98,7 +104,9 @@ class SmallVector {
     m_storage_end = inline_begin() + inline_elt_count;
   }
 
-  bool using_heap_storage() const { return m_storage_begin != inline_begin(); }
+  bool using_heap_storage() const {
+    return m_storage_begin != inline_begin();
+  }
 
   /*!
    * Allocate (if needed) storage to hold size objects.
@@ -200,7 +208,9 @@ class SmallVector {
   /*!
    * Constructor a SmallVector. By default the size is 0 and no elements are constructed.
    */
-  SmallVector() { initialize_storage_and_size(0); }
+  SmallVector() {
+    initialize_storage_and_size(0);
+  }
 
   /*!
    * Initialize vector with count elements that are default initialized
@@ -340,7 +350,9 @@ class SmallVector {
   /*!
    * See note on other assign.
    */
-  void assign(std::initializer_list<T> lst) { *this = SmallVector<T, inline_elt_count>(lst); }
+  void assign(std::initializer_list<T> lst) {
+    *this = SmallVector<T, inline_elt_count>(lst);
+  }
 
   /*!
    * Get the element at the index. Assert the index is valid.
@@ -361,59 +373,103 @@ class SmallVector {
   /*!
    * Get the element at the index. No range checking.
    */
-  T& operator[](std::size_t idx) { return m_storage_begin[idx]; }
+  T& operator[](std::size_t idx) {
+    return m_storage_begin[idx];
+  }
 
   /*!
    * Get the element at the index. No range checking.
    */
-  const T& operator[](std::size_t idx) const { return m_storage_begin[idx]; }
+  const T& operator[](std::size_t idx) const {
+    return m_storage_begin[idx];
+  }
 
   /*!
    * Get the first element. Not valid if size == 0
    */
-  T& front() { return m_storage_begin[0]; }
+  T& front() {
+    return m_storage_begin[0];
+  }
 
   /*!
    * Get the first element. Not valid if size == 0
    */
-  const T& front() const { return m_storage_begin[0]; }
+  const T& front() const {
+    return m_storage_begin[0];
+  }
 
   /*!
    * Get the last element. Not valid if size == 0
    */
-  T& back() { return m_storage_begin[m_size - 1]; }
+  T& back() {
+    return m_storage_begin[m_size - 1];
+  }
 
   /*!
    * Get the last element. Not valid if size == 0
    */
-  const T& back() const { return m_storage_begin[m_size - 1]; }
+  const T& back() const {
+    return m_storage_begin[m_size - 1];
+  }
 
   /*!
    * Get a pointer to data. This may become invalid after any resize, just like a std::vector.
    */
-  T* data() { return m_storage_begin; }
+  T* data() {
+    return m_storage_begin;
+  }
 
   /*!
    * Get a pointer to data. This may become invalid after any resize, just like a std::vector.
    */
-  const T* data() const { return m_storage_begin; }
+  const T* data() const {
+    return m_storage_begin;
+  }
 
-  iterator begin() { return m_storage_begin; }
-  const_iterator begin() const { return m_storage_begin; }
-  const_iterator cbegin() const { return m_storage_begin; }
-  iterator end() { return m_storage_begin + m_size; }
-  const_iterator end() const { return m_storage_begin + m_size; }
-  const_iterator cend() const { return m_storage_begin + m_size; }
+  iterator begin() {
+    return m_storage_begin;
+  }
+  const_iterator begin() const {
+    return m_storage_begin;
+  }
+  const_iterator cbegin() const {
+    return m_storage_begin;
+  }
+  iterator end() {
+    return m_storage_begin + m_size;
+  }
+  const_iterator end() const {
+    return m_storage_begin + m_size;
+  }
+  const_iterator cend() const {
+    return m_storage_begin + m_size;
+  }
 
-  reverse_iterator rbegin() { return m_storage_begin + m_size; }
-  const_reverse_iterator rbegin() const { return m_storage_begin + m_size; }
-  const_reverse_iterator crbegin() const { return m_storage_begin + m_size; }
-  reverse_iterator rend() { return m_storage_begin; }
-  const_reverse_iterator rend() const { return m_storage_begin; }
-  const_reverse_iterator crend() const { return m_storage_begin; }
+  reverse_iterator rbegin() {
+    return m_storage_begin + m_size;
+  }
+  const_reverse_iterator rbegin() const {
+    return m_storage_begin + m_size;
+  }
+  const_reverse_iterator crbegin() const {
+    return m_storage_begin + m_size;
+  }
+  reverse_iterator rend() {
+    return m_storage_begin;
+  }
+  const_reverse_iterator rend() const {
+    return m_storage_begin;
+  }
+  const_reverse_iterator crend() const {
+    return m_storage_begin;
+  }
 
-  bool empty() const { return m_size == 0; }
-  std::size_t size() const { return m_size; }
+  bool empty() const {
+    return m_size == 0;
+  }
+  std::size_t size() const {
+    return m_size;
+  }
 
   /*!
    * Make sure we have enough storage to hold desired_count without allocating.
@@ -439,7 +495,9 @@ class SmallVector {
   /*!
    * The number of elements we can hold without allocating more memory.
    */
-  std::size_t capacity() const { return m_storage_end - m_storage_begin; }
+  std::size_t capacity() const {
+    return m_storage_end - m_storage_begin;
+  }
 
   /*!
    * Shrink our heap allocation to the smallest possible size that can possibly hold the
@@ -544,7 +602,9 @@ class SmallVector {
     m_size++;
   }
 
-  void pop_back() { m_size--; }
+  void pop_back() {
+    m_size--;
+  }
 
   void relocate_some_and_destroy_rest(T* dst,
                                       T* src,