Merge pull request #95 from winny-/throw_by_value_catch_by_reference

Throw exceptions by value, catch by reference

src/keyboard.cpp

     }
     // Non-fatal.
     if ( err != GrabSuccess ) {
-        //throw new std::runtime_error( "Couldn't grab the keyboard after 10 tries." );
+        //throw std::runtime_error( "Couldn't grab the keyboard after 10 tries." );
     }
     XQueryKeymap( x11->display, deltaState );
     keyDown = false;

src/main.cpp

             value = value.substr(sz+1);
             found[3] = std::stof(value,&sz);
             if ( value.size() != sz ) {
-                throw "dur";
+                throw std::runtime_error("dur");
             }
         } else {
             found[3] = 1;
         }
     } catch ( ... ) {
-        throw new std::invalid_argument("Unable to parse value `" + valuecopy + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1.");
+        throw std::invalid_argument("Unable to parse value `" + valuecopy + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1.");
     }
     return found;
 }
     if ( options.count( "nodecorations" ) > 0 ) {
         foo->nodecorations = options["nodecorations"].as<int>();
         if ( foo->nodecorations < 0 || foo->nodecorations > 2 ) {
-            throw new std::invalid_argument( "--nodecorations must be between 0 and 2. Or be used as a flag." );
+            throw std::invalid_argument( "--nodecorations must be between 0 and 2. Or be used as a flag." );
         }
     }
     return foo;
     for( unsigned int i=0;i<input.length();i++) {
         if ( input[i] == '%' ) {
             if ( input.length() <= i+1 ) {
-                throw new std::invalid_argument( "Expected character after `%`, got END." );
+                throw std::invalid_argument( "Expected character after `%`, got END." );
             }
             switch( input[i+1] ) {
                 case 'x':
                 case 'i':
                 case 'I': output << selection.id; break;
                 case '%': output << "%"; break;
-                default: throw new std::invalid_argument( std::string()+"Expected x, y, w, h, g, i, c, or % after % in format. Got `" + input[i+1] + "`." );
+                default: throw std::invalid_argument( std::string()+"Expected x, y, w, h, g, i, c, or % after % in format. Got `" + input[i+1] + "`." );
              }
             i++;
             continue;
     // Options just validates all of our input from argv
     auto& positional = options["positional"].as<std::vector<std::string>>();
     if ( positional.size() > 0 ) {
-        throw new std::invalid_argument("Unexpected positional argument: " + positional[0]);
+        throw std::invalid_argument("Unexpected positional argument: " + positional[0]);
     }
     bool help = false;
     if ( options.count( "help" ) > 0 ) {
 int main( int argc, char** argv ) {
     try {
         return app( argc, argv );
-    } catch( std::exception* e ) {
-        std::cerr << "Slop encountered an error:\n" << e->what() << "\n";
+    } catch( std::exception& e ) {
+        std::cerr << "Slop encountered an error:\n" << e.what() << "\n";
         return 1;
     } // let the operating system handle any other kind of exception.
     return 1;

src/mouse.cpp

         tries++;
     }
     if ( err != GrabSuccess ) {
-        throw new std::runtime_error( "Couldn't grab the mouse after 10 tries." );
+        throw std::runtime_error( "Couldn't grab the mouse after 10 tries." );
     }
     this->nodecorations = nodecorations;
     this->ignoreWindow = ignoreWindow;

src/resource.cpp

         return usrconfig + localpath;
     }
     std::string err = "The file or folder " + localpath + " was not found in " + usrconfig + "\n";
-    throw new std::runtime_error(err);
+    throw std::runtime_error(err);
     return localpath;
 }
 

src/shader.cpp

         frag = resource->getRealPath(frag);
         std::ifstream v( vert.c_str() );
         if (!v.is_open()) {
-            throw new std::runtime_error( "Failed to open " + vert );
+            throw std::runtime_error( "Failed to open " + vert );
         }
         vert_contents = std::string((std::istreambuf_iterator<char>(v)),
                                    std::istreambuf_iterator<char>());
         std::ifstream f( frag.c_str() );
         if (!f.is_open()) {
-            throw new std::runtime_error( "Failed to open " + frag );
+            throw std::runtime_error( "Failed to open " + frag );
         }
         frag_contents = std::string((std::istreambuf_iterator<char>(f)),
                                   std::istreambuf_iterator<char>());
     
     if ( vert_contents.length() <= 0 ) {
         std::string errstring = "Failed to open file (or is empty) `" + vert + "`.\n";
-        throw new std::runtime_error(errstring);
+        throw std::runtime_error(errstring);
     }
 
     if ( frag_contents.length() <= 0 ) {
         std::string errstring = "Failed to open file (or is empty) `" + frag + "`.\n";
-        throw new std::runtime_error(errstring);
+        throw std::runtime_error(errstring);
     }
 
     // Compile both shaders.
 
     if ( err ) {
         std::string errstring = "Failed to compile shader `" + vert + "`:\n" + errortxt;
-        throw new std::runtime_error(errstring);
+        throw std::runtime_error(errstring);
         glDeleteShader( vertShader );
         return;
     }
     err = compile( fragShader, errortxt );
     if ( err ) {
         std::string errstring = "Failed to compile shader `" + frag + "`:\n" + errortxt;
-        throw new std::runtime_error(errstring);
+        throw std::runtime_error(errstring);
         glDeleteShader( vertShader );
         glDeleteShader( fragShader );
         return;
     err = link( vertShader, fragShader, errortxt );
     if ( err ) {
         std::string errstring = "Failed to link shader `" + vert + "` and  `" + frag + "`:\n" + errortxt;
-        throw new std::runtime_error(errstring);
+        throw std::runtime_error(errstring);
         glDeleteShader( vertShader );
         glDeleteShader( fragShader );
         return;

src/slop.cpp

             window = new SlopWindow();
             if (!GLEW_VERSION_3_0) {
                 delete window;
-                throw new std::runtime_error( "OpenGL version is not high enough, slop requires OpenGL 3.0!\nOpenGL accelleration is disabled. Use -o or -q to suppress this message." );
+                throw std::runtime_error( "OpenGL version is not high enough, slop requires OpenGL 3.0!\nOpenGL accelleration is disabled. Use -o or -q to suppress this message." );
             }
             success = true;
-        } catch( std::exception* e ) {
-            errorstring += std::string(e->what()) + "\n";
+        } catch( std::exception& e ) {
+            errorstring += std::string(e.what()) + "\n";
             success = false;
         } catch (...) {
             success = false;
                 case GL_OUT_OF_MEMORY: error="OUT_OF_MEMORY"; break;
                 case GL_INVALID_FRAMEBUFFER_OPERATION: error="INVALID_FRAMEBUFFER_OPERATION"; break;
             }
-            throw new std::runtime_error( "OpenGL threw an error: " + error );
+            throw std::runtime_error( "OpenGL threw an error: " + error );
         }
         if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
             memory->running = false;

src/window.cpp

     int nelements;
     int render_event_base, render_error_base;
     if(!XRenderQueryExtension(x11->display, &render_event_base, &render_error_base)) {
-        throw new std::runtime_error("No XRENDER extension found\n");
+        throw std::runtime_error("No XRENDER extension found\n");
     }
 
     GLXFBConfig* fbc = glXChooseFBConfig(x11->display, DefaultScreen(x11->display), attributeList, &nelements);
     GLXFBConfig fbconfig;
     if ( !fbc ) {
-        throw new std::runtime_error("No matching visuals available.\n");
+        throw std::runtime_error("No matching visuals available.\n");
     }
     XVisualInfo* vi ;
     XRenderPictFormat *pictFormat;
         }
     }
     if (i == nelements ) {
-        throw new std::runtime_error( "No matching visuals available" );
+        throw std::runtime_error( "No matching visuals available" );
     }
     XFree( fbc );
 
     XFree( vi );
 
     if ( !window ) {
-        throw new std::runtime_error( "Couldn't create a GL window!" );
+        throw std::runtime_error( "Couldn't create a GL window!" );
     }
 
     // Prep some hints for the window
 
     context = glXCreateNewContext( x11->display, fbconfig, GLX_RGBA_TYPE, 0, True );
     if ( !context ) {
-        throw new std::runtime_error( "Failed to create an OpenGL context." );
+        throw std::runtime_error( "Failed to create an OpenGL context." );
     }
     setCurrent();
     // Finally we grab some OpenGL 3.3 stuffs.
     GLenum err = glewInit();
     if (GLEW_OK != err)
     {
-      throw new std::runtime_error((char*)glewGetErrorString(err));
+      throw std::runtime_error((char*)glewGetErrorString(err));
     }
     framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
 

src/x.cpp

     // Initialize display
     display = XOpenDisplay( displayName.c_str() );
     if ( !display ) {
-        throw new std::runtime_error(std::string("Error: Failed to open X display: ") + displayName );
+        throw std::runtime_error(std::string("Error: Failed to open X display: ") + displayName );
     }
     screen = ScreenOfDisplay( display, DefaultScreen( display ) );
     visual = DefaultVisual( display, XScreenNumberOfScreen( screen ) );

src/xshaperectangle.cpp

     xc.blue = blue;
     int err = XAllocColor( x11->display, DefaultColormap( x11->display, XScreenNumberOfScreen( x11->screen ) ), &xc );
     if ( err == BadColor ) {
-        throw new std::runtime_error(std::string("Couldn't allocate a color"));
+        throw std::runtime_error(std::string("Couldn't allocate a color"));
     }
     return xc;
 }