MAINT: Use exceptions to propagate errors

src/presolve/HPresolve.cpp

@@ -3817,11 +3817,22 @@ HPresolve::Result HPresolve::initialRowAndColPresolve(
   // arrays are not initialized, also unset changedRowFlag so that the row will
   // be added to the changed row vector when it is changed after it was
   // processed
-  for (HighsInt row = 0; row != model->num_row_; ++row) {
-    if (rowDeleted[row]) continue;
-    HPRESOLVE_CHECKED_CALL(rowPresolve(postsolve_stack, row));
-    changedRowFlag[row] = false;
-  }
+try {
+    for (HighsInt row = 0; row != model->num_row_; ++row) {
+        if (rowDeleted[row]) continue;
+        HPRESOLVE_CHECKED_CALL(rowPresolve(postsolve_stack, row));
+        changedRowFlag[row] = false;
+    }
+} catch(const ProblemTooLargeException& e) {
+    std::cerr << "The problem is too large to be presolved with the current resources.\n";
+    std::cerr << "A problem occurred during execution: " << e.what() << std::endl;
+    std::cerr << "Model details: \n";
+    std::cerr << "Number of rows: " << model->num_row_ << "\n";
+    // Add additional model details as needed
+    // Once the necessary information is printed, you could decide whether to terminate or propagate the error further.
+    // Here we re-throw the error to allow higher level code to decide on next steps
+    throw;
+}
 
   // same for the columns
   for (HighsInt col = 0; col != model->num_col_; ++col) {

src/presolve/HPresolve.h

@@ -32,6 +32,7 @@
 #include "util/HighsHash.h"
 #include "util/HighsLinearSumBounds.h"
 #include "util/HighsMatrixSlice.h"
+#include "util/HighsExceptions.h"
 
 namespace presolve {
 

src/presolve/HighsPostsolveStack.h

@@ -24,6 +24,7 @@
 #include <tuple>
 #include <vector>
 
+#include "HighsExceptions.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HStruct.h"
 #include "lp_data/HighsOptions.h"
@@ -367,6 +368,7 @@ class HighsPostsolveStack {
   template <typename ColStorageFormat>
   void fixedColAtLower(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {
+  try {
     assert(std::isfinite(fixValue));
     colValues.clear();
     for (const HighsSliceNonzero& colVal : colVec)
@@ -376,8 +378,12 @@ class HighsPostsolveStack {
                                   HighsBasisStatus::kLower});
     reductionValues.push(colValues);
     reductionAdded(ReductionType::kFixedCol);
+  } catch(const DataStackOverflow& e) {
+    std::cerr << "Memory allocation failed while processing fixedColAtLower: " << e.what() << std::endl;
+    // Throw another exception.
+    throw PresolveTooLarge("The problem cannot be pre-solved, either lower the size or try without presolve");
   }
-
+}
   template <typename ColStorageFormat>
   void fixedColAtUpper(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {

src/util/HighsDataStack.h

@@ -20,8 +20,10 @@
 #include <cstring>
 #include <type_traits>
 #include <vector>
+#include <string>
 
 #include "util/HighsInt.h"
+#include "util/HighsExceptions.h"
 
 #if __GNUG__ && __GNUC__ < 5
 #define IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
@@ -40,10 +42,18 @@ class HighsDataStack {
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void push(const T& r) {
     HighsInt dataSize = data.size();
-    data.resize(dataSize + sizeof(T));
-    std::memcpy(data.data() + dataSize, &r, sizeof(T));
+    HighsInt newSize = dataSize + sizeof(T);
+  try {
+    data.resize(newSize);
+  } catch (const std::length_error& e) {
+    throw DataStackOverflow(
+        "Failed to resize the vector. Requested new size: " +
+        std::to_string(newSize) +
+        ". Size to add is "+std::to_string(sizeof(T))+"."+
+        ". Current size: " + std::to_string(data.size()) + ".");
   }
-
+  std::memcpy(data.data() + dataSize, &r, sizeof(T));
+}
   template <typename T,
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void pop(T& r) {