WIP: Switch from custom VError to standard runtime_error

lovell · lovell · commit 17d4a684df51 · 2026-01-23T22:26:15.000Z
diff --git a/src/common.cc b/src/common.cc
@@ -510,11 +510,11 @@ namespace sharp {
               option = GetOptionsForImageType(imageType, descriptor);
               image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input buffer contains unsupported image format");
+          throw std::runtime_error("Input buffer contains unsupported image format");
         }
       }
     } else {
@@ -585,10 +585,10 @@ namespace sharp {
         imageType = DetermineImageType(descriptor->file.data());
         if (imageType == ImageType::MISSING) {
           if (descriptor->file.find("<svg") != std::string::npos) {
-            throw vips::VError("Input file is missing, did you mean "
+            throw std::runtime_error("Input file is missing, did you mean "
               "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
           }
-          throw vips::VError("Input file is missing: " + descriptor->file);
+          throw std::runtime_error("Input file is missing: " + descriptor->file);
         }
         if (imageType != ImageType::UNKNOWN) {
           try {
@@ -600,19 +600,19 @@ namespace sharp {
               option = GetOptionsForImageType(imageType, descriptor);
               image = VImage::new_from_file(descriptor->file.data(), option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input file contains unsupported image format");
+          throw std::runtime_error("Input file contains unsupported image format");
         }
       }
     }
 
     // Limit input images to a given number of pixels, where pixels = width * height
     if (descriptor->limitInputPixels > 0 &&
       static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {
-      throw vips::VError("Input image exceeds pixel limit");
+      throw std::runtime_error("Input image exceeds pixel limit");
     }
     return std::make_tuple(image, imageType);
   }
@@ -788,19 +788,19 @@ namespace sharp {
       : image.height();
     if (imageType == ImageType::JPEG) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the JPEG format");
+        throw std::runtime_error("Processed image is too large for the JPEG format");
       }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || height > 16383) {
-        throw vips::VError("Processed image is too large for the WebP format");
+        throw std::runtime_error("Processed image is too large for the WebP format");
       }
     } else if (imageType == ImageType::GIF) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the GIF format");
+        throw std::runtime_error("Processed image is too large for the GIF format");
       }
     } else if (imageType == ImageType::HEIF) {
       if (image.width() > 16384 || height > 16384) {
-        throw vips::VError("Processed image is too large for the HEIF format");
+        throw std::runtime_error("Processed image is too large for the HEIF format");
       }
     }
   }
diff --git a/src/metadata.cc b/src/metadata.cc
@@ -31,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
diff --git a/src/operations.cc b/src/operations.cc
@@ -14,7 +14,6 @@
 #include "./operations.h"
 
 using vips::VImage;
-using vips::VError;
 
 namespace sharp {
   /*
@@ -287,7 +286,7 @@ namespace sharp {
   */
   VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin) {
     if (image.width() < 3 && image.height() < 3) {
-      throw VError("Image to trim must be at least 3x3 pixels");
+      throw std::runtime_error("Image to trim must be at least 3x3 pixels");
     }
     if (background.size() == 0) {
       // Top-left pixel provides the default background colour if none is given
@@ -361,7 +360,7 @@ namespace sharp {
   VImage Linear(VImage image, std::vector<double> const a, std::vector<double> const b) {
     size_t const bands = static_cast<size_t>(image.bands());
     if (a.size() > bands) {
-      throw VError("Band expansion using linear is unsupported");
+      throw std::runtime_error("Band expansion using linear is unsupported");
     }
     bool const uchar = !Is16Bit(image.interpretation());
     if (image.has_alpha() && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {
diff --git a/src/pipeline.cc b/src/pipeline.cc
@@ -274,7 +274,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           sharp::SetDensity(image, baton->input->density);
           if (image.width() > 32767 || image.height() > 32767) {
-            throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");
+            throw std::runtime_error("Input SVG image will exceed 32767x32767 pixel limit when scaled");
           }
         } else if (inputImageType == sharp::ImageType::PDF) {
           if (baton->input->buffer != nullptr) {
@@ -290,7 +290,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
       } else {
         if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 || image.height() > 32767)) {
-          throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");
+          throw std::runtime_error("Input SVG image exceeds 32767x32767 pixel limit");
         }
       }
       if (baton->input->autoOrient) {
@@ -675,7 +675,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
           // Verify within current dimensions
           if (compositeImage.width() > image.width() || compositeImage.height() > image.height()) {
-            throw vips::VError("Image to composite must have same dimensions or smaller");
+            throw std::runtime_error("Image to composite must have same dimensions or smaller");
           }
           // Check if overlay is tiled
           if (composite->tile) {
@@ -1086,20 +1086,19 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Get raw image data
           baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));
           if (baton->bufferOut == nullptr) {
-            (baton->err).append("Could not allocate enough memory for raw output");
-            return Error();
+            throw std::runtime_error("Could not allocate enough memory for raw output");
           }
           baton->formatOut = "raw";
         } else {
           // Unsupported output format
-          (baton->err).append("Unsupported output format ");
+          auto unsupported = std::string("Unsupported output format ");
           if (baton->formatOut == "input") {
-            (baton->err).append("when trying to match input format of ");
-            (baton->err).append(ImageTypeId(inputImageType));
+            unsupported.append("when trying to match input format of ");
+            unsupported.append(ImageTypeId(inputImageType));
           } else {
-            (baton->err).append(baton->formatOut);
+            unsupported.append(baton->formatOut);
           }
-          return Error();
+          throw std::runtime_error(unsupported);
         }
       } else {
         // File output
@@ -1274,7 +1273,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           return Error();
         }
       }
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       char const *what = err.what();
       if (what && what[0]) {
         (baton->err).append(what);
@@ -1306,7 +1305,6 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       int width = baton->width;
       int height = baton->height;
@@ -1407,7 +1405,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
   void MultiPageUnsupported(int const pages, std::string op) {
     if (pages > 1) {
-      throw vips::VError(op + " is not supported for multi-page images");
+      throw std::runtime_error(op + " is not supported for multi-page images");
     }
   }
 
diff --git a/src/stats.cc b/src/stats.cc
@@ -39,7 +39,7 @@ class StatsWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
@@ -92,7 +92,7 @@ class StatsWorker : public Napi::AsyncWorker {
         baton->dominantRed = dx * 16 + 8;
         baton->dominantGreen = dy * 16 + 8;
         baton->dominantBlue = dz * 16 + 8;
-      } catch (vips::VError const &err) {
+      } catch (std::runtime_error const &err) {
         (baton->err).append(err.what());
       }
     }
@@ -112,7 +112,6 @@ class StatsWorker : public Napi::AsyncWorker {
       debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       // Stats Object
       Napi::Object info = Napi::Object::New(env);
diff --git a/src/utilities.cc b/src/utilities.cc
@@ -244,7 +244,7 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
     }
     // Calculate colour distance
     maxColourDistance = image1.dE00(image2).max();
-  } catch (vips::VError const &err) {
+  } catch (std::runtime_error const &err) {
     throw Napi::Error::New(env, err.what());
   }
 

Original file line number	Diff line number	Diff line change
`@@ -510,11 +510,11 @@ namespace sharp {`
`510`	`510`	`option = GetOptionsForImageType(imageType, descriptor);`
`511`	`511`	`image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);`
`512`	`512`	`}`
`513`		`- } catch (vips::VError const &err) {`
`514`		`- throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());`
	`513`	`+ } catch (std::runtime_error const &err) {`
	`514`	`+ throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());`
`515`	`515`	`}`
`516`	`516`	`} else {`
`517`		`- throw vips::VError("Input buffer contains unsupported image format");`
	`517`	`+ throw std::runtime_error("Input buffer contains unsupported image format");`
`518`	`518`	`}`
`519`	`519`	`}`
`520`	`520`	`} else {`
`@@ -585,10 +585,10 @@ namespace sharp {`
`585`	`585`	`imageType = DetermineImageType(descriptor->file.data());`
`586`	`586`	`if (imageType == ImageType::MISSING) {`
`587`	`587`	`if (descriptor->file.find("<svg") != std::string::npos) {`
`588`		`- throw vips::VError("Input file is missing, did you mean "`
	`588`	`+ throw std::runtime_error("Input file is missing, did you mean "`
`589`	`589`	`"sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");`
`590`	`590`	`}`
`591`		`- throw vips::VError("Input file is missing: " + descriptor->file);`
	`591`	`+ throw std::runtime_error("Input file is missing: " + descriptor->file);`
`592`	`592`	`}`
`593`	`593`	`if (imageType != ImageType::UNKNOWN) {`
`594`	`594`	`try {`
`@@ -600,19 +600,19 @@ namespace sharp {`
`600`	`600`	`option = GetOptionsForImageType(imageType, descriptor);`
`601`	`601`	`image = VImage::new_from_file(descriptor->file.data(), option);`
`602`	`602`	`}`
`603`		`- } catch (vips::VError const &err) {`
`604`		`- throw vips::VError(std::string("Input file has corrupt header: ") + err.what());`
	`603`	`+ } catch (std::runtime_error const &err) {`
	`604`	`+ throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());`
`605`	`605`	`}`
`606`	`606`	`} else {`
`607`		`- throw vips::VError("Input file contains unsupported image format");`
	`607`	`+ throw std::runtime_error("Input file contains unsupported image format");`
`608`	`608`	`}`
`609`	`609`	`}`
`610`	`610`	`}`
`611`	`611`
`612`	`612`	`// Limit input images to a given number of pixels, where pixels = width * height`
`613`	`613`	`if (descriptor->limitInputPixels > 0 &&`
`614`	`614`	`static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {`
`615`		`- throw vips::VError("Input image exceeds pixel limit");`
	`615`	`+ throw std::runtime_error("Input image exceeds pixel limit");`
`616`	`616`	`}`
`617`	`617`	`return std::make_tuple(image, imageType);`
`618`	`618`	`}`
`@@ -788,19 +788,19 @@ namespace sharp {`
`788`	`788`	`: image.height();`
`789`	`789`	`if (imageType == ImageType::JPEG) {`
`790`	`790`	`if (image.width() > 65535 \|\| height > 65535) {`
`791`		`- throw vips::VError("Processed image is too large for the JPEG format");`
	`791`	`+ throw std::runtime_error("Processed image is too large for the JPEG format");`
`792`	`792`	`}`
`793`	`793`	`} else if (imageType == ImageType::WEBP) {`
`794`	`794`	`if (image.width() > 16383 \|\| height > 16383) {`
`795`		`- throw vips::VError("Processed image is too large for the WebP format");`
	`795`	`+ throw std::runtime_error("Processed image is too large for the WebP format");`
`796`	`796`	`}`
`797`	`797`	`} else if (imageType == ImageType::GIF) {`
`798`	`798`	`if (image.width() > 65535 \|\| height > 65535) {`
`799`		`- throw vips::VError("Processed image is too large for the GIF format");`
	`799`	`+ throw std::runtime_error("Processed image is too large for the GIF format");`
`800`	`800`	`}`
`801`	`801`	`} else if (imageType == ImageType::HEIF) {`
`802`	`802`	`if (image.width() > 16384 \|\| height > 16384) {`
`803`		`- throw vips::VError("Processed image is too large for the HEIF format");`
	`803`	`+ throw std::runtime_error("Processed image is too large for the HEIF format");`
`804`	`804`	`}`
`805`	`805`	`}`
`806`	`806`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {`
`31`	`31`	`sharp::ImageType imageType = sharp::ImageType::UNKNOWN;`
`32`	`32`	`try {`
`33`	`33`	`std::tie(image, imageType) = OpenInput(baton->input);`
`34`		`- } catch (vips::VError const &err) {`
	`34`	`+ } catch (std::runtime_error const &err) {`
`35`	`35`	`(baton->err).append(err.what());`
`36`	`36`	`}`
`37`	`37`	`if (imageType != sharp::ImageType::UNKNOWN) {`
Original file line number	Diff line number	Diff line change
`@@ -274,7 +274,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`274`	`274`	`}`
`275`	`275`	`sharp::SetDensity(image, baton->input->density);`
`276`	`276`	`if (image.width() > 32767 \|\| image.height() > 32767) {`
`277`		`- throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");`
	`277`	`+ throw std::runtime_error("Input SVG image will exceed 32767x32767 pixel limit when scaled");`
`278`	`278`	`}`
`279`	`279`	`} else if (inputImageType == sharp::ImageType::PDF) {`
`280`	`280`	`if (baton->input->buffer != nullptr) {`
`@@ -290,7 +290,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`290`	`290`	`}`
`291`	`291`	`} else {`
`292`	`292`	`if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 \|\| image.height() > 32767)) {`
`293`		`- throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");`
	`293`	`+ throw std::runtime_error("Input SVG image exceeds 32767x32767 pixel limit");`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`	`if (baton->input->autoOrient) {`
`@@ -675,7 +675,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`675`	`675`
`676`	`676`	`// Verify within current dimensions`
`677`	`677`	`if (compositeImage.width() > image.width() \|\| compositeImage.height() > image.height()) {`
`678`		`- throw vips::VError("Image to composite must have same dimensions or smaller");`
	`678`	`+ throw std::runtime_error("Image to composite must have same dimensions or smaller");`
`679`	`679`	`}`
`680`	`680`	`// Check if overlay is tiled`
`681`	`681`	`if (composite->tile) {`
`@@ -1086,20 +1086,19 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1086`	`1086`	`// Get raw image data`
`1087`	`1087`	`baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));`
`1088`	`1088`	`if (baton->bufferOut == nullptr) {`
`1089`		`- (baton->err).append("Could not allocate enough memory for raw output");`
`1090`		`- return Error();`
	`1089`	`+ throw std::runtime_error("Could not allocate enough memory for raw output");`
`1091`	`1090`	`}`
`1092`	`1091`	`baton->formatOut = "raw";`
`1093`	`1092`	`} else {`
`1094`	`1093`	`// Unsupported output format`
`1095`		`- (baton->err).append("Unsupported output format ");`
	`1094`	`+ auto unsupported = std::string("Unsupported output format ");`
`1096`	`1095`	`if (baton->formatOut == "input") {`
`1097`		`- (baton->err).append("when trying to match input format of ");`
`1098`		`- (baton->err).append(ImageTypeId(inputImageType));`
	`1096`	`+ unsupported.append("when trying to match input format of ");`
	`1097`	`+ unsupported.append(ImageTypeId(inputImageType));`
`1099`	`1098`	`} else {`
`1100`		`- (baton->err).append(baton->formatOut);`
	`1099`	`+ unsupported.append(baton->formatOut);`
`1101`	`1100`	`}`
`1102`		`- return Error();`
	`1101`	`+ throw std::runtime_error(unsupported);`
`1103`	`1102`	`}`
`1104`	`1103`	`} else {`
`1105`	`1104`	`// File output`
`@@ -1274,7 +1273,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1274`	`1273`	`return Error();`
`1275`	`1274`	`}`
`1276`	`1275`	`}`
`1277`		`- } catch (vips::VError const &err) {`
	`1276`	`+ } catch (std::runtime_error const &err) {`
`1278`	`1277`	`char const *what = err.what();`
`1279`	`1278`	`if (what && what[0]) {`
`1280`	`1279`	`(baton->err).append(what);`
`@@ -1306,7 +1305,6 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1306`	`1305`	`}`
`1307`	`1306`	`warning = sharp::VipsWarningPop();`
`1308`	`1307`	`}`
`1309`		`-`
`1310`	`1308`	`if (baton->err.empty()) {`
`1311`	`1309`	`int width = baton->width;`
`1312`	`1310`	`int height = baton->height;`
`@@ -1407,7 +1405,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1407`	`1405`
`1408`	`1406`	`void MultiPageUnsupported(int const pages, std::string op) {`
`1409`	`1407`	`if (pages > 1) {`
`1410`		`- throw vips::VError(op + " is not supported for multi-page images");`
	`1408`	`+ throw std::runtime_error(op + " is not supported for multi-page images");`
`1411`	`1409`	`}`
`1412`	`1410`	`}`
`1413`	`1411`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class StatsWorker : public Napi::AsyncWorker {`
`39`	`39`	`sharp::ImageType imageType = sharp::ImageType::UNKNOWN;`
`40`	`40`	`try {`
`41`	`41`	`std::tie(image, imageType) = OpenInput(baton->input);`
`42`		`- } catch (vips::VError const &err) {`
	`42`	`+ } catch (std::runtime_error const &err) {`
`43`	`43`	`(baton->err).append(err.what());`
`44`	`44`	`}`
`45`	`45`	`if (imageType != sharp::ImageType::UNKNOWN) {`
`@@ -92,7 +92,7 @@ class StatsWorker : public Napi::AsyncWorker {`
`92`	`92`	`baton->dominantRed = dx * 16 + 8;`
`93`	`93`	`baton->dominantGreen = dy * 16 + 8;`
`94`	`94`	`baton->dominantBlue = dz * 16 + 8;`
`95`		`- } catch (vips::VError const &err) {`
	`95`	`+ } catch (std::runtime_error const &err) {`
`96`	`96`	`(baton->err).append(err.what());`
`97`	`97`	`}`
`98`	`98`	`}`
`@@ -112,7 +112,6 @@ class StatsWorker : public Napi::AsyncWorker {`
`112`	`112`	`debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });`
`113`	`113`	`warning = sharp::VipsWarningPop();`
`114`	`114`	`}`
`115`		`-`
`116`	`115`	`if (baton->err.empty()) {`
`117`	`116`	`// Stats Object`
`118`	`117`	`Napi::Object info = Napi::Object::New(env);`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {`
`244`	`244`	`}`
`245`	`245`	`// Calculate colour distance`
`246`	`246`	`maxColourDistance = image1.dE00(image2).max();`
`247`		`- } catch (vips::VError const &err) {`
	`247`	`+ } catch (std::runtime_error const &err) {`
`248`	`248`	`throw Napi::Error::New(env, err.what());`
`249`	`249`	`}`
`250`	`250`