Throw std::runtime_exception instead of char*.

anntzer · anntzer · commit df7995460d9e · 2017-10-05T13:33:46.000-07:00
This should make it easier to debug exceptions falling out of the C++
code, as the C++ runtime will print the error message (the `what()` of
the exception) on its way to aborting the program.

Did a regex replace; removed the `char*` handler in CALL_CPP_FULL; and
remove a bunch of extra whitespace.
diff --git a/lib/matplotlib/tri/_tri.cpp b/lib/matplotlib/tri/_tri.cpp
@@ -1400,7 +1400,7 @@ TrapezoidMapTriFinder::initialize()
     unsigned int nedges = _edges.size();
     for (unsigned int index = 2; index < nedges; ++index) {
         if (!add_edge_to_tree(_edges[index]))
-            throw "Triangulation is invalid";
+            throw std::runtime_error("Triangulation is invalid");
         _tree->assert_valid(index == nedges-1);
     }
 }
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -101,7 +101,7 @@ BufferRegion *RendererAgg::copy_from_bbox(agg::rect_d in_rect)
 void RendererAgg::restore_region(BufferRegion &region)
 {
     if (region.get_data() == NULL) {
-        throw "Cannot restore_region from NULL data";
+        throw std::runtime_error("Cannot restore_region from NULL data");
     }
 
     agg::rendering_buffer rbuf;
@@ -115,7 +115,7 @@ void
 RendererAgg::restore_region(BufferRegion &region, int xx1, int yy1, int xx2, int yy2, int x, int y )
 {
     if (region.get_data() == NULL) {
-        throw "Cannot restore_region from NULL data";
+        throw std::runtime_error("Cannot restore_region from NULL data");
     }
 
     agg::rect_i &rrect = region.get_rect();
diff --git a/src/_contour.cpp b/src/_contour.cpp
@@ -398,7 +398,7 @@ void QuadContourGenerator::append_contour_line_to_vertices(
     }
     if (PyList_Append(vertices_list, line.pyobj_steal())) {
         Py_XDECREF(vertices_list);
-        throw "Unable to add contour line to vertices_list";
+        throw std::runtime_error("Unable to add contour line to vertices_list");
     }
 
     contour_line.clear();
@@ -475,7 +475,7 @@ void QuadContourGenerator::append_contour_to_vertices_and_codes(
                 Py_XDECREF(vertices_list);
                 Py_XDECREF(codes_list);
                 contour.delete_contour_lines();
-                throw "Unable to add contour line to vertices and codes lists";
+                throw std::runtime_error("Unable to add contour line to vertices and codes lists");
             }
 
             delete *line_it;
@@ -510,7 +510,7 @@ PyObject* QuadContourGenerator::create_contour(const double& level)
 
     PyObject* vertices_list = PyList_New(0);
     if (vertices_list == 0)
-        throw "Failed to create Python list";
+        throw std::runtime_error("Failed to create Python list");
 
     // Lines that start and end on boundaries.
     long ichunk, jchunk, istart, iend, jstart, jend;
@@ -602,12 +602,12 @@ PyObject* QuadContourGenerator::create_filled_contour(const double& lower_level,
 
     PyObject* vertices = PyList_New(0);
     if (vertices == 0)
-        throw "Failed to create Python list";
+        throw std::runtime_error("Failed to create Python list");
 
     PyObject* codes = PyList_New(0);
     if (codes == 0) {
         Py_XDECREF(vertices);
-        throw "Failed to create Python list";
+        throw std::runtime_error("Failed to create Python list");
     }
 
     long ichunk, jchunk, istart, iend, jstart, jend;
@@ -644,7 +644,7 @@ PyObject* QuadContourGenerator::create_filled_contour(const double& lower_level,
     if (tuple == 0) {
         Py_XDECREF(vertices);
         Py_XDECREF(codes);
-        throw "Failed to create Python tuple";
+        throw std::runtime_error("Failed to create Python tuple");
     }
 
     // No error checking here as filling in a brand new pre-allocated tuple.
diff --git a/src/_image.h b/src/_image.h
@@ -35,7 +35,7 @@ void pcolor(CoordinateArray &x,
             OutputArray &out)
 {
     if (rows >= 32768 || cols >= 32768) {
-        throw "rows and cols must both be less than 32768";
+        throw std::runtime_error("rows and cols must both be less than 32768");
     }
 
     float x_min = bounds[0];
@@ -49,18 +49,18 @@ void pcolor(CoordinateArray &x,
 
     // Check we have something to output to
     if (rows == 0 || cols == 0) {
-        throw "Cannot scale to zero size";
+        throw std::runtime_error("Cannot scale to zero size");
     }
 
     if (d.dim(2) != 4) {
-        throw "data must be in RGBA format";
+        throw std::runtime_error("data must be in RGBA format");
     }
 
     // Check dimensions match
     unsigned long nx = x.dim(0);
     unsigned long ny = y.dim(0);
     if (nx != (unsigned long)d.dim(1) || ny != (unsigned long)d.dim(0)) {
-        throw "data and axis dimensions do not match";
+        throw std::runtime_error("data and axis dimensions do not match");
     }
 
     // Allocate memory for pointer arrays
@@ -150,22 +150,22 @@ void pcolor2(CoordinateArray &x,
 
     // Check we have something to output to
     if (rows == 0 || cols == 0) {
-        throw "rows or cols is zero; there are no pixels";
+        throw std::runtime_error("rows or cols is zero; there are no pixels");
     }
 
     if (d.dim(2) != 4) {
-        throw "data must be in RGBA format";
+        throw std::runtime_error("data must be in RGBA format");
     }
 
     // Check dimensions match
     unsigned long nx = x.dim(0);
     unsigned long ny = y.dim(0);
     if (nx != (unsigned long)d.dim(1) + 1 || ny != (unsigned long)d.dim(0) + 1) {
-        throw "data and axis bin boundary dimensions are incompatible";
+        throw std::runtime_error("data and axis bin boundary dimensions are incompatible");
     }
 
     if (bg.dim(0) != 4) {
-        throw "bg must be in RGBA format";
+        throw std::runtime_error("bg must be in RGBA format");
     }
 
     std::vector<int> irows(rows);
diff --git a/src/_path.h b/src/_path.h
@@ -393,7 +393,7 @@ void get_path_collection_extents(agg::trans_affine &master_transform,
                                  extent_limits &extent)
 {
     if (offsets.size() != 0 && offsets.dim(1) != 2) {
-        throw "Offsets array must be Nx2";
+        throw std::runtime_error("Offsets array must be Nx2");
     }
 
     size_t Npaths = paths.size();
@@ -728,7 +728,7 @@ template <class VerticesArray, class ResultArray>
 void affine_transform_2d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)
 {
     if (vertices.size() != 0 && vertices.dim(1) != 2) {
-        throw "Invalid vertices array.";
+        throw std::runtime_error("Invalid vertices array.");
     }
 
     size_t n = vertices.size();
@@ -758,7 +758,7 @@ template <class VerticesArray, class ResultArray>
 void affine_transform_1d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)
 {
     if (vertices.dim(0) != 2) {
-        throw "Invalid vertices array.";
+        throw std::runtime_error("Invalid vertices array.");
     }
 
     double x;
diff --git a/src/array.h b/src/array.h
@@ -52,12 +52,12 @@ class empty
 
     T &operator()(int i, int j = 0, int k = 0)
     {
-        throw "Accessed empty array";
+        throw std::runtime_error("Accessed empty array");
     }
 
     const T &operator()(int i, int j = 0, int k = 0) const
     {
-        throw "Accessed empty array";
+        throw std::runtime_error("Accessed empty array");
     }
 
     sub_t operator[](int i) const
diff --git a/src/ft2font.cpp b/src/ft2font.cpp
@@ -2,8 +2,9 @@
 
 #define NO_IMPORT_ARRAY
 
-#include <string>
 #include <algorithm>
+#include <stdexcept>
+#include <string>
 
 #include "ft2font.h"
 #include "mplutils.h"
@@ -115,7 +116,7 @@ void FT2Image::draw_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y)
             }
         }
     } else {
-        throw "Unknown pixel mode";
+        throw std::runtime_error("Unknown pixel mode");
     }
 
     m_dirty = true;
@@ -124,7 +125,7 @@ void FT2Image::draw_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y)
 void FT2Image::draw_rect(unsigned long x0, unsigned long y0, unsigned long x1, unsigned long y1)
 {
     if (x0 > m_width || x1 > m_width || y0 > m_height || y1 > m_height) {
-        throw "Rect coords outside image bounds";
+        throw std::runtime_error("Rect coords outside image bounds");
     }
 
     size_t top = y0 * m_width;
@@ -170,7 +171,7 @@ int FT2Font::get_path_count()
     // this code is from agg's decompose_ft_outline with minor modifications
 
     if (!face->glyph) {
-        throw "No glyph loaded";
+        throw std::runtime_error("No glyph loaded");
     }
 
     FT_Outline &outline = face->glyph->outline;
@@ -208,7 +209,7 @@ int FT2Font::get_path_count()
 
         // A contour cannot start with a cubic control point!
         if (tag == FT_CURVE_TAG_CUBIC) {
-            throw "A contour cannot start with a cubic control point";
+            throw std::runtime_error("A contour cannot start with a cubic control point");
         } else if (tag == FT_CURVE_TAG_CONIC) {
             starts_with_last = true;
         } else {
@@ -246,7 +247,7 @@ int FT2Font::get_path_count()
                     }
 
                     if (tag != FT_CURVE_TAG_CONIC) {
-                        throw "Invalid font";
+                        throw std::runtime_error("Invalid font");
                     }
 
                     count += 2;
@@ -262,7 +263,7 @@ int FT2Font::get_path_count()
             default: // FT_CURVE_TAG_CUBIC
             {
                 if (point + 1 > limit || FT_CURVE_TAG(tags[1]) != FT_CURVE_TAG_CUBIC) {
-                    throw "Invalid font";
+                    throw std::runtime_error("Invalid font");
                 }
 
                 point += 2;
@@ -492,13 +493,13 @@ FT2Font::FT2Font(FT_Open_Args &open_args, long hinting_factor_) : image(), face(
     int error = FT_Open_Face(_ft2Library, &open_args, 0, &face);
 
     if (error == FT_Err_Unknown_File_Format) {
-        throw "Can not load face.  Unknown file format.";
+        throw std::runtime_error("Can not load face.  Unknown file format.");
     } else if (error == FT_Err_Cannot_Open_Resource) {
-        throw "Can not load face.  Can not open resource.";
+        throw std::runtime_error("Can not load face.  Can not open resource.");
     } else if (error == FT_Err_Invalid_File_Format) {
-        throw "Can not load face.  Invalid file format.";
+        throw std::runtime_error("Can not load face.  Invalid file format.");
     } else if (error) {
-        throw "Can not load face.";
+        throw std::runtime_error("Can not load face.");
     }
 
     // set a default fontsize 12 pt at 72dpi
@@ -507,7 +508,7 @@ FT2Font::FT2Font(FT_Open_Args &open_args, long hinting_factor_) : image(), face(
     error = FT_Set_Char_Size(face, 12 * 64, 0, 72 * (unsigned int)hinting_factor, 72);
     if (error) {
         FT_Done_Face(face);
-        throw "Could not set the fontsize";
+        throw std::runtime_error("Could not set the fontsize");
     }
 
     if (open_args.stream != NULL) {
@@ -551,25 +552,25 @@ void FT2Font::set_size(double ptsize, double dpi)
     FT_Set_Transform(face, &transform, 0);
 
     if (error) {
-        throw "Could not set the fontsize";
+        throw std::runtime_error("Could not set the fontsize");
     }
 }
 
 void FT2Font::set_charmap(int i)
 {
     if (i >= face->num_charmaps) {
-        throw "i exceeds the available number of char maps";
+        throw std::runtime_error("i exceeds the available number of char maps");
     }
     FT_CharMap charmap = face->charmaps[i];
     if (FT_Set_Charmap(face, charmap)) {
-        throw "Could not set the charmap";
+        throw std::runtime_error("Could not set the charmap");
     }
 }
 
 void FT2Font::select_charmap(unsigned long i)
 {
     if (FT_Select_Charmap(face, (FT_Encoding)i)) {
-        throw "Could not set the charmap";
+        throw std::runtime_error("Could not set the charmap");
     }
 }
 
@@ -624,7 +625,7 @@ void FT2Font::set_text(
         }
         error = FT_Load_Glyph(face, glyph_index, flags);
         if (error) {
-            throw "could not load glyph";
+            throw std::runtime_error("could not load glyph");
         }
         // ignore errors, jump to next glyph
 
@@ -634,7 +635,7 @@ void FT2Font::set_text(
         error = FT_Get_Glyph(face->glyph, &thisGlyph);
 
         if (error) {
-            throw "could not get glyph";
+            throw std::runtime_error("could not get glyph");
         }
         // ignore errors, jump to next glyph
 
@@ -670,14 +671,14 @@ void FT2Font::load_char(long charcode, FT_Int32 flags)
     int error = FT_Load_Char(face, (unsigned long)charcode, flags);
 
     if (error) {
-        throw "Could not load charcode";
+        throw std::runtime_error("Could not load charcode");
     }
 
     FT_Glyph thisGlyph;
     error = FT_Get_Glyph(face->glyph, &thisGlyph);
 
     if (error) {
-        throw "Could not get glyph";
+        throw std::runtime_error("Could not get glyph");
     }
 
     glyphs.push_back(thisGlyph);
@@ -688,14 +689,14 @@ void FT2Font::load_glyph(FT_UInt glyph_index, FT_Int32 flags)
     int error = FT_Load_Glyph(face, glyph_index, flags);
 
     if (error) {
-        throw "Could not load glyph";
+        throw std::runtime_error("Could not load glyph");
     }
 
     FT_Glyph thisGlyph;
     error = FT_Get_Glyph(face->glyph, &thisGlyph);
 
     if (error) {
-        throw "Could not load glyph";
+        throw std::runtime_error("Could not load glyph");
     }
 
     glyphs.push_back(thisGlyph);
@@ -729,7 +730,7 @@ void FT2Font::draw_glyphs_to_bitmap(bool antialiased)
         error = FT_Glyph_To_Bitmap(
             &glyphs[n], antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);
         if (error) {
-            throw "Could not convert glyph to bitmap";
+            throw std::runtime_error("Could not convert glyph to bitmap");
         }
 
         FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];
@@ -750,7 +751,7 @@ void FT2Font::get_xys(bool antialiased, std::vector<double> &xys)
         error = FT_Glyph_To_Bitmap(
             &glyphs[n], antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);
         if (error) {
-            throw "Could not convert glyph to bitmap";
+            throw std::runtime_error("Could not convert glyph to bitmap");
         }
 
         FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];
@@ -773,7 +774,7 @@ void FT2Font::draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd,
     sub_offset.y = 0; // int((yd - (double)y) * 64.0);
 
     if (glyphInd >= glyphs.size()) {
-        throw "glyph num is out of range";
+        throw std::runtime_error("glyph num is out of range");
     }
 
     error = FT_Glyph_To_Bitmap(&glyphs[glyphInd],
@@ -782,7 +783,7 @@ void FT2Font::draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd,
                                1 // destroy image
                                );
     if (error) {
-        throw "Could not convert glyph to bitmap";
+        throw std::runtime_error("Could not convert glyph to bitmap");
     }
 
     FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[glyphInd];
@@ -798,7 +799,7 @@ void FT2Font::get_glyph_name(unsigned int glyph_number, char *buffer)
         PyOS_snprintf(buffer, 128, "uni%08x", glyph_number);
     } else {
         if (FT_Get_Glyph_Name(face, glyph_number, buffer, 128)) {
-            throw "Could not get glyph names.";
+            throw std::runtime_error("Could not get glyph names.");
         }
     }
 }
diff --git a/src/ft2font_wrapper.cpp b/src/ft2font_wrapper.cpp
diff --git a/src/py_exceptions.h b/src/py_exceptions.h

Original file line number	Diff line number	Diff line change
`@@ -1400,7 +1400,7 @@ TrapezoidMapTriFinder::initialize()`
`1400`	`1400`	`unsigned int nedges = _edges.size();`
`1401`	`1401`	`for (unsigned int index = 2; index < nedges; ++index) {`
`1402`	`1402`	`if (!add_edge_to_tree(_edges[index]))`
`1403`		`- throw "Triangulation is invalid";`
	`1403`	`+ throw std::runtime_error("Triangulation is invalid");`
`1404`	`1404`	`_tree->assert_valid(index == nedges-1);`
`1405`	`1405`	`}`
`1406`	`1406`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ BufferRegion *RendererAgg::copy_from_bbox(agg::rect_d in_rect)`
`101`	`101`	`void RendererAgg::restore_region(BufferRegion &region)`
`102`	`102`	`{`
`103`	`103`	`if (region.get_data() == NULL) {`
`104`		`- throw "Cannot restore_region from NULL data";`
	`104`	`+ throw std::runtime_error("Cannot restore_region from NULL data");`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`agg::rendering_buffer rbuf;`
`@@ -115,7 +115,7 @@ void`
`115`	`115`	`RendererAgg::restore_region(BufferRegion &region, int xx1, int yy1, int xx2, int yy2, int x, int y )`
`116`	`116`	`{`
`117`	`117`	`if (region.get_data() == NULL) {`
`118`		`- throw "Cannot restore_region from NULL data";`
	`118`	`+ throw std::runtime_error("Cannot restore_region from NULL data");`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`agg::rect_i &rrect = region.get_rect();`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ void pcolor(CoordinateArray &x,`
`35`	`35`	`OutputArray &out)`
`36`	`36`	`{`
`37`	`37`	`if (rows >= 32768 \|\| cols >= 32768) {`
`38`		`- throw "rows and cols must both be less than 32768";`
	`38`	`+ throw std::runtime_error("rows and cols must both be less than 32768");`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`float x_min = bounds[0];`
`@@ -49,18 +49,18 @@ void pcolor(CoordinateArray &x,`
`49`	`49`
`50`	`50`	`// Check we have something to output to`
`51`	`51`	`if (rows == 0 \|\| cols == 0) {`
`52`		`- throw "Cannot scale to zero size";`
	`52`	`+ throw std::runtime_error("Cannot scale to zero size");`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`if (d.dim(2) != 4) {`
`56`		`- throw "data must be in RGBA format";`
	`56`	`+ throw std::runtime_error("data must be in RGBA format");`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`// Check dimensions match`
`60`	`60`	`unsigned long nx = x.dim(0);`
`61`	`61`	`unsigned long ny = y.dim(0);`
`62`	`62`	`if (nx != (unsigned long)d.dim(1) \|\| ny != (unsigned long)d.dim(0)) {`
`63`		`- throw "data and axis dimensions do not match";`
	`63`	`+ throw std::runtime_error("data and axis dimensions do not match");`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`// Allocate memory for pointer arrays`
`@@ -150,22 +150,22 @@ void pcolor2(CoordinateArray &x,`
`150`	`150`
`151`	`151`	`// Check we have something to output to`
`152`	`152`	`if (rows == 0 \|\| cols == 0) {`
`153`		`- throw "rows or cols is zero; there are no pixels";`
	`153`	`+ throw std::runtime_error("rows or cols is zero; there are no pixels");`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`if (d.dim(2) != 4) {`
`157`		`- throw "data must be in RGBA format";`
	`157`	`+ throw std::runtime_error("data must be in RGBA format");`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`// Check dimensions match`
`161`	`161`	`unsigned long nx = x.dim(0);`
`162`	`162`	`unsigned long ny = y.dim(0);`
`163`	`163`	`if (nx != (unsigned long)d.dim(1) + 1 \|\| ny != (unsigned long)d.dim(0) + 1) {`
`164`		`- throw "data and axis bin boundary dimensions are incompatible";`
	`164`	`+ throw std::runtime_error("data and axis bin boundary dimensions are incompatible");`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`if (bg.dim(0) != 4) {`
`168`		`- throw "bg must be in RGBA format";`
	`168`	`+ throw std::runtime_error("bg must be in RGBA format");`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`std::vector<int> irows(rows);`
Original file line number	Diff line number	Diff line change
`@@ -393,7 +393,7 @@ void get_path_collection_extents(agg::trans_affine &master_transform,`
`393`	`393`	`extent_limits &extent)`
`394`	`394`	`{`
`395`	`395`	`if (offsets.size() != 0 && offsets.dim(1) != 2) {`
`396`		`- throw "Offsets array must be Nx2";`
	`396`	`+ throw std::runtime_error("Offsets array must be Nx2");`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`size_t Npaths = paths.size();`
`@@ -728,7 +728,7 @@ template <class VerticesArray, class ResultArray>`
`728`	`728`	`void affine_transform_2d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)`
`729`	`729`	`{`
`730`	`730`	`if (vertices.size() != 0 && vertices.dim(1) != 2) {`
`731`		`- throw "Invalid vertices array.";`
	`731`	`+ throw std::runtime_error("Invalid vertices array.");`
`732`	`732`	`}`
`733`	`733`
`734`	`734`	`size_t n = vertices.size();`
`@@ -758,7 +758,7 @@ template <class VerticesArray, class ResultArray>`
`758`	`758`	`void affine_transform_1d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)`
`759`	`759`	`{`
`760`	`760`	`if (vertices.dim(0) != 2) {`
`761`		`- throw "Invalid vertices array.";`
	`761`	`+ throw std::runtime_error("Invalid vertices array.");`
`762`	`762`	`}`
`763`	`763`
`764`	`764`	`double x;`
Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,12 @@ class empty`
`52`	`52`
`53`	`53`	`T &operator()(int i, int j = 0, int k = 0)`
`54`	`54`	`{`
`55`		`- throw "Accessed empty array";`
	`55`	`+ throw std::runtime_error("Accessed empty array");`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`const T &operator()(int i, int j = 0, int k = 0) const`
`59`	`59`	`{`
`60`		`- throw "Accessed empty array";`
	`60`	`+ throw std::runtime_error("Accessed empty array");`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`sub_t operator[](int i) const`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,9 @@`
`2`	`2`
`3`	`3`	`#define NO_IMPORT_ARRAY`
`4`	`4`
`5`		`-#include <string>`
`6`	`5`	`#include <algorithm>`
	`6`	`+#include <stdexcept>`
	`7`	`+#include <string>`
`7`	`8`
`8`	`9`	`#include "ft2font.h"`
`9`	`10`	`#include "mplutils.h"`
`@@ -115,7 +116,7 @@ void FT2Image::draw_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y)`
`115`	`116`	`}`
`116`	`117`	`}`
`117`	`118`	`} else {`
`118`		`- throw "Unknown pixel mode";`
	`119`	`+ throw std::runtime_error("Unknown pixel mode");`
`119`	`120`	`}`
`120`	`121`
`121`	`122`	`m_dirty = true;`
`@@ -124,7 +125,7 @@ void FT2Image::draw_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y)`
`124`	`125`	`void FT2Image::draw_rect(unsigned long x0, unsigned long y0, unsigned long x1, unsigned long y1)`
`125`	`126`	`{`
`126`	`127`	`if (x0 > m_width \|\| x1 > m_width \|\| y0 > m_height \|\| y1 > m_height) {`
`127`		`- throw "Rect coords outside image bounds";`
	`128`	`+ throw std::runtime_error("Rect coords outside image bounds");`
`128`	`129`	`}`
`129`	`130`
`130`	`131`	`size_t top = y0 * m_width;`
`@@ -170,7 +171,7 @@ int FT2Font::get_path_count()`
`170`	`171`	`// this code is from agg's decompose_ft_outline with minor modifications`
`171`	`172`
`172`	`173`	`if (!face->glyph) {`
`173`		`- throw "No glyph loaded";`
	`174`	`+ throw std::runtime_error("No glyph loaded");`
`174`	`175`	`}`
`175`	`176`
`176`	`177`	`FT_Outline &outline = face->glyph->outline;`
`@@ -208,7 +209,7 @@ int FT2Font::get_path_count()`
`208`	`209`
`209`	`210`	`// A contour cannot start with a cubic control point!`
`210`	`211`	`if (tag == FT_CURVE_TAG_CUBIC) {`
`211`		`- throw "A contour cannot start with a cubic control point";`
	`212`	`+ throw std::runtime_error("A contour cannot start with a cubic control point");`
`212`	`213`	`} else if (tag == FT_CURVE_TAG_CONIC) {`
`213`	`214`	`starts_with_last = true;`
`214`	`215`	`} else {`
`@@ -246,7 +247,7 @@ int FT2Font::get_path_count()`
`246`	`247`	`}`
`247`	`248`
`248`	`249`	`if (tag != FT_CURVE_TAG_CONIC) {`
`249`		`- throw "Invalid font";`
	`250`	`+ throw std::runtime_error("Invalid font");`
`250`	`251`	`}`
`251`	`252`
`252`	`253`	`count += 2;`
`@@ -262,7 +263,7 @@ int FT2Font::get_path_count()`
`262`	`263`	`default: // FT_CURVE_TAG_CUBIC`
`263`	`264`	`{`
`264`	`265`	`if (point + 1 > limit \|\| FT_CURVE_TAG(tags[1]) != FT_CURVE_TAG_CUBIC) {`
`265`		`- throw "Invalid font";`
	`266`	`+ throw std::runtime_error("Invalid font");`
`266`	`267`	`}`
`267`	`268`
`268`	`269`	`point += 2;`
`@@ -492,13 +493,13 @@ FT2Font::FT2Font(FT_Open_Args &open_args, long hinting_factor_) : image(), face(`
`492`	`493`	`int error = FT_Open_Face(_ft2Library, &open_args, 0, &face);`
`493`	`494`
`494`	`495`	`if (error == FT_Err_Unknown_File_Format) {`
`495`		`- throw "Can not load face. Unknown file format.";`
	`496`	`+ throw std::runtime_error("Can not load face. Unknown file format.");`
`496`	`497`	`} else if (error == FT_Err_Cannot_Open_Resource) {`
`497`		`- throw "Can not load face. Can not open resource.";`
	`498`	`+ throw std::runtime_error("Can not load face. Can not open resource.");`
`498`	`499`	`} else if (error == FT_Err_Invalid_File_Format) {`
`499`		`- throw "Can not load face. Invalid file format.";`
	`500`	`+ throw std::runtime_error("Can not load face. Invalid file format.");`
`500`	`501`	`} else if (error) {`
`501`		`- throw "Can not load face.";`
	`502`	`+ throw std::runtime_error("Can not load face.");`
`502`	`503`	`}`
`503`	`504`
`504`	`505`	`// set a default fontsize 12 pt at 72dpi`
`@@ -507,7 +508,7 @@ FT2Font::FT2Font(FT_Open_Args &open_args, long hinting_factor_) : image(), face(`
`507`	`508`	`error = FT_Set_Char_Size(face, 12 * 64, 0, 72 * (unsigned int)hinting_factor, 72);`
`508`	`509`	`if (error) {`
`509`	`510`	`FT_Done_Face(face);`
`510`		`- throw "Could not set the fontsize";`
	`511`	`+ throw std::runtime_error("Could not set the fontsize");`
`511`	`512`	`}`
`512`	`513`
`513`	`514`	`if (open_args.stream != NULL) {`
`@@ -551,25 +552,25 @@ void FT2Font::set_size(double ptsize, double dpi)`
`551`	`552`	`FT_Set_Transform(face, &transform, 0);`
`552`	`553`
`553`	`554`	`if (error) {`
`554`		`- throw "Could not set the fontsize";`
	`555`	`+ throw std::runtime_error("Could not set the fontsize");`
`555`	`556`	`}`
`556`	`557`	`}`
`557`	`558`
`558`	`559`	`void FT2Font::set_charmap(int i)`
`559`	`560`	`{`
`560`	`561`	`if (i >= face->num_charmaps) {`
`561`		`- throw "i exceeds the available number of char maps";`
	`562`	`+ throw std::runtime_error("i exceeds the available number of char maps");`
`562`	`563`	`}`
`563`	`564`	`FT_CharMap charmap = face->charmaps[i];`
`564`	`565`	`if (FT_Set_Charmap(face, charmap)) {`
`565`		`- throw "Could not set the charmap";`
	`566`	`+ throw std::runtime_error("Could not set the charmap");`
`566`	`567`	`}`
`567`	`568`	`}`
`568`	`569`
`569`	`570`	`void FT2Font::select_charmap(unsigned long i)`
`570`	`571`	`{`
`571`	`572`	`if (FT_Select_Charmap(face, (FT_Encoding)i)) {`
`572`		`- throw "Could not set the charmap";`
	`573`	`+ throw std::runtime_error("Could not set the charmap");`
`573`	`574`	`}`
`574`	`575`	`}`
`575`	`576`
`@@ -624,7 +625,7 @@ void FT2Font::set_text(`
`624`	`625`	`}`
`625`	`626`	`error = FT_Load_Glyph(face, glyph_index, flags);`
`626`	`627`	`if (error) {`
`627`		`- throw "could not load glyph";`
	`628`	`+ throw std::runtime_error("could not load glyph");`
`628`	`629`	`}`
`629`	`630`	`// ignore errors, jump to next glyph`
`630`	`631`
`@@ -634,7 +635,7 @@ void FT2Font::set_text(`
`634`	`635`	`error = FT_Get_Glyph(face->glyph, &thisGlyph);`
`635`	`636`
`636`	`637`	`if (error) {`
`637`		`- throw "could not get glyph";`
	`638`	`+ throw std::runtime_error("could not get glyph");`
`638`	`639`	`}`
`639`	`640`	`// ignore errors, jump to next glyph`
`640`	`641`
`@@ -670,14 +671,14 @@ void FT2Font::load_char(long charcode, FT_Int32 flags)`
`670`	`671`	`int error = FT_Load_Char(face, (unsigned long)charcode, flags);`
`671`	`672`
`672`	`673`	`if (error) {`
`673`		`- throw "Could not load charcode";`
	`674`	`+ throw std::runtime_error("Could not load charcode");`
`674`	`675`	`}`
`675`	`676`
`676`	`677`	`FT_Glyph thisGlyph;`
`677`	`678`	`error = FT_Get_Glyph(face->glyph, &thisGlyph);`
`678`	`679`
`679`	`680`	`if (error) {`
`680`		`- throw "Could not get glyph";`
	`681`	`+ throw std::runtime_error("Could not get glyph");`
`681`	`682`	`}`
`682`	`683`
`683`	`684`	`glyphs.push_back(thisGlyph);`
`@@ -688,14 +689,14 @@ void FT2Font::load_glyph(FT_UInt glyph_index, FT_Int32 flags)`
`688`	`689`	`int error = FT_Load_Glyph(face, glyph_index, flags);`
`689`	`690`
`690`	`691`	`if (error) {`
`691`		`- throw "Could not load glyph";`
	`692`	`+ throw std::runtime_error("Could not load glyph");`
`692`	`693`	`}`
`693`	`694`
`694`	`695`	`FT_Glyph thisGlyph;`
`695`	`696`	`error = FT_Get_Glyph(face->glyph, &thisGlyph);`
`696`	`697`
`697`	`698`	`if (error) {`
`698`		`- throw "Could not load glyph";`
	`699`	`+ throw std::runtime_error("Could not load glyph");`
`699`	`700`	`}`
`700`	`701`
`701`	`702`	`glyphs.push_back(thisGlyph);`
`@@ -729,7 +730,7 @@ void FT2Font::draw_glyphs_to_bitmap(bool antialiased)`
`729`	`730`	`error = FT_Glyph_To_Bitmap(`
`730`	`731`	`&glyphs[n], antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);`
`731`	`732`	`if (error) {`
`732`		`- throw "Could not convert glyph to bitmap";`
	`733`	`+ throw std::runtime_error("Could not convert glyph to bitmap");`
`733`	`734`	`}`
`734`	`735`
`735`	`736`	`FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];`
`@@ -750,7 +751,7 @@ void FT2Font::get_xys(bool antialiased, std::vector<double> &xys)`
`750`	`751`	`error = FT_Glyph_To_Bitmap(`
`751`	`752`	`&glyphs[n], antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);`
`752`	`753`	`if (error) {`
`753`		`- throw "Could not convert glyph to bitmap";`
	`754`	`+ throw std::runtime_error("Could not convert glyph to bitmap");`
`754`	`755`	`}`
`755`	`756`
`756`	`757`	`FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];`
`@@ -773,7 +774,7 @@ void FT2Font::draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd,`
`773`	`774`	`sub_offset.y = 0; // int((yd - (double)y) * 64.0);`
`774`	`775`
`775`	`776`	`if (glyphInd >= glyphs.size()) {`
`776`		`- throw "glyph num is out of range";`
	`777`	`+ throw std::runtime_error("glyph num is out of range");`
`777`	`778`	`}`
`778`	`779`
`779`	`780`	`error = FT_Glyph_To_Bitmap(&glyphs[glyphInd],`
`@@ -782,7 +783,7 @@ void FT2Font::draw_glyph_to_bitmap(FT2Image &im, int x, int y, size_t glyphInd,`
`782`	`783`	`1 // destroy image`
`783`	`784`	`);`
`784`	`785`	`if (error) {`
`785`		`- throw "Could not convert glyph to bitmap";`
	`786`	`+ throw std::runtime_error("Could not convert glyph to bitmap");`
`786`	`787`	`}`
`787`	`788`
`788`	`789`	`FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[glyphInd];`
`@@ -798,7 +799,7 @@ void FT2Font::get_glyph_name(unsigned int glyph_number, char *buffer)`
`798`	`799`	`PyOS_snprintf(buffer, 128, "uni%08x", glyph_number);`
`799`	`800`	`} else {`
`800`	`801`	`if (FT_Get_Glyph_Name(face, glyph_number, buffer, 128)) {`
`801`		`- throw "Could not get glyph names.";`
	`802`	`+ throw std::runtime_error("Could not get glyph names.");`
`802`	`803`	`}`
`803`	`804`	`}`
`804`	`805`	`}`