Add braces for the main functions in the new source files at samples

samples/crwedit.cpp

@@ -15,70 +15,73 @@ void add(Exiv2::Internal::CiffHeader* pHead);
 void help();
 void write(const std::string& filename, const Exiv2::Internal::CiffHeader* pHead);
 
-int main(int argc, char* const argv[]) try {
+int main(int argc, char* const argv[])
-    if (argc != 2) {
+{
-        std::cout << "Usage: " << argv[0] << " file\n";
+    try {
-        std::cout << "Edit the CIFF structure of a CRW file\n";
+        if (argc != 2) {
-        return 1;
+            std::cout << "Usage: " << argv[0] << " file\n";
-    }
+            std::cout << "Edit the CIFF structure of a CRW file\n";
+            return 1;
+        }
 
-    std::string filename(argv[1]);
+        std::string filename(argv[1]);
-    Exiv2::FileIo io(filename);
+        Exiv2::FileIo io(filename);
-    if (io.open() != 0) {
+        if (io.open() != 0) {
-        throw Exiv2::Error(Exiv2::kerDataSourceOpenFailed, io.path(), Exiv2::strError());
+            throw Exiv2::Error(Exiv2::kerDataSourceOpenFailed, io.path(), Exiv2::strError());
-    }
+        }
-    Exiv2::IoCloser closer(io);
+        Exiv2::IoCloser closer(io);
+
+        // Ensure that this is a CRW image
+        if (!Exiv2::isCrwType(io, false)) {
+            if (io.error() || io.eof())
+                throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
+            throw Exiv2::Error(Exiv2::kerNotACrwImage);
+        }
 
-    // Ensure that this is a CRW image
+        // Read the image into a memory buffer
-    if (!Exiv2::isCrwType(io, false)) {
+        long len = (long)io.size();
+        Exiv2::DataBuf buf(len);
+        io.read(buf.pData_, len);
         if (io.error() || io.eof())
             throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
-        throw Exiv2::Error(Exiv2::kerNotACrwImage);
-    }
 
-    // Read the image into a memory buffer
+        // Parse the image, starting with a CIFF header component
-    long len = (long)io.size();
+        Exiv2::Internal::CiffHeader::AutoPtr parseTree(new Exiv2::Internal::CiffHeader);
-    Exiv2::DataBuf buf(len);
+        parseTree->read(buf.pData_, buf.size_);
-    io.read(buf.pData_, len);
-    if (io.error() || io.eof())
-        throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
 
-    // Parse the image, starting with a CIFF header component
+        // Allow user to make changes
-    Exiv2::Internal::CiffHeader::AutoPtr parseTree(new Exiv2::Internal::CiffHeader);
+        bool go = true;
-    parseTree->read(buf.pData_, buf.size_);
+        while (go) {
-
+            char cmd;
-    // Allow user to make changes
+            std::cout << "command> ";
-    bool go = true;
+            std::cin >> cmd;
-    while (go) {
+            switch (cmd) {
-        char cmd;
+                case 'q':
-        std::cout << "command> ";
+                    go = false;
-        std::cin >> cmd;
+                    break;
-        switch (cmd) {
+                case 'p':
-            case 'q':
+                    parseTree->print(std::cout);
-                go = false;
+                    break;
-                break;
+                case 'a':
-            case 'p':
+                    add(parseTree.get());
-                parseTree->print(std::cout);
+                    break;
-                break;
+                case 'd':
-            case 'a':
+                    remove(parseTree.get());
-                add(parseTree.get());
+                    break;
-                break;
+                case 'w':
-            case 'd':
+                    write(filename, parseTree.get());
-                remove(parseTree.get());
+                    break;
-                break;
+                case 'h':
-            case 'w':
+                    help();
-                write(filename, parseTree.get());
+                    break;
-                break;
+            }
-            case 'h':
-                help();
-                break;
         }
-    }
 
-    return 0;
+        return 0;
-} catch (Exiv2::AnyError& e) {
+    } catch (Exiv2::AnyError& e) {
-    std::cerr << e << "\n";
+        std::cerr << e << "\n";
-    return -1;
+        return -1;
+    }
 }
 
 void write(const std::string& filename, const Exiv2::Internal::CiffHeader* pHead)

samples/crwparse.cpp

@@ -8,40 +8,43 @@
 
 #include <iostream>
 
-int main(int argc, char* const argv[]) try {
+int main(int argc, char* const argv[])
-    if (argc != 2) {
+{
-        std::cout << "Usage: " << argv[0] << " file\n";
+    try {
-        std::cout << "Print the CIFF structure of a CRW file\n";
+        if (argc != 2) {
-        return 1;
+            std::cout << "Usage: " << argv[0] << " file\n";
-    }
+            std::cout << "Print the CIFF structure of a CRW file\n";
-
+            return 1;
-    Exiv2::FileIo io(argv[1]);
+        }
-    if (io.open() != 0) {
+
-        throw Exiv2::Error(Exiv2::kerDataSourceOpenFailed, io.path(), Exiv2::strError());
+        Exiv2::FileIo io(argv[1]);
-    }
+        if (io.open() != 0) {
-    Exiv2::IoCloser closer(io);
+            throw Exiv2::Error(Exiv2::kerDataSourceOpenFailed, io.path(), Exiv2::strError());
-
+        }
-    // Ensure that this is a CRW image
+        Exiv2::IoCloser closer(io);
-    if (!Exiv2::isCrwType(io, false)) {
+
+        // Ensure that this is a CRW image
+        if (!Exiv2::isCrwType(io, false)) {
+            if (io.error() || io.eof())
+                throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
+            throw Exiv2::Error(Exiv2::kerNotACrwImage);
+        }
+
+        // Read the image into a memory buffer
+        long len = io.size();
+        Exiv2::DataBuf buf(len);
+        io.read(buf.pData_, len);
         if (io.error() || io.eof())
             throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
-        throw Exiv2::Error(Exiv2::kerNotACrwImage);
-    }
 
-    // Read the image into a memory buffer
+        // Parse the image, starting with a CIFF header component
-    long len = io.size();
+        Exiv2::Internal::CiffHeader::AutoPtr parseTree(new Exiv2::Internal::CiffHeader);
-    Exiv2::DataBuf buf(len);
+        parseTree->read(buf.pData_, buf.size_);
-    io.read(buf.pData_, len);
+        parseTree->print(std::cout);
-    if (io.error() || io.eof())
+
-        throw Exiv2::Error(Exiv2::kerFailedToReadImageData);
+        return 0;
-
+    } catch (Exiv2::AnyError& e) {
-    // Parse the image, starting with a CIFF header component
+        std::cerr << e << "\n";
-    Exiv2::Internal::CiffHeader::AutoPtr parseTree(new Exiv2::Internal::CiffHeader);
+        return -1;
-    parseTree->read(buf.pData_, buf.size_);
+    }
-    parseTree->print(std::cout);
-
-    return 0;
-} catch (Exiv2::AnyError& e) {
-    std::cerr << e << "\n";
-    return -1;
 }

samples/mrwthumb.cpp

@@ -7,41 +7,44 @@
 #include "exif.hpp"
 #include "image.hpp"
 
-int main(int argc, char* const argv[]) try {
+int main(int argc, char* const argv[])
-    if (argc != 2) {
+{
-        std::cout << "Usage: " << argv[0] << " file\n";
+    try {
-        return 1;
+        if (argc != 2) {
+            std::cout << "Usage: " << argv[0] << " file\n";
+            return 1;
+        }
+
+        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
+        assert(image.get() != 0);
+        image->readMetadata();
+
+        Exiv2::ExifData& exifData = image->exifData();
+        if (exifData.empty()) {
+            std::string error(argv[1]);
+            error += ": No Exif data found in the file";
+            throw Exiv2::Error(Exiv2::kerErrorMessage, error);
+        }
+
+        Exiv2::ExifKey key("Exif.Minolta.ThumbnailOffset");
+        Exiv2::ExifData::const_iterator format = exifData.findKey(key);
+
+        if (format != exifData.end()) {
+            Exiv2::DataBuf buf = format->dataArea();
+
+            // The first byte of the buffer needs to be patched
+            buf.pData_[0] = 0xff;
+
+            Exiv2::FileIo file("img_thumb.jpg");
+
+            file.open("wb");
+            file.write(buf.pData_, buf.size_);
+            file.close();
+        }
+
+        return 0;
+    } catch (Exiv2::AnyError& e) {
+        std::cout << "Caught Exiv2 exception '" << e << "'\n";
+        return -1;
     }
-
-    Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
-    assert(image.get() != 0);
-    image->readMetadata();
-
-    Exiv2::ExifData& exifData = image->exifData();
-    if (exifData.empty()) {
-        std::string error(argv[1]);
-        error += ": No Exif data found in the file";
-        throw Exiv2::Error(Exiv2::kerErrorMessage, error);
-    }
-
-    Exiv2::ExifKey key("Exif.Minolta.ThumbnailOffset");
-    Exiv2::ExifData::const_iterator format = exifData.findKey(key);
-
-    if (format != exifData.end()) {
-        Exiv2::DataBuf buf = format->dataArea();
-
-        // The first byte of the buffer needs to be patched
-        buf.pData_[0] = 0xff;
-
-        Exiv2::FileIo file("img_thumb.jpg");
-
-        file.open("wb");
-        file.write(buf.pData_, buf.size_);
-        file.close();
-    }
-
-    return 0;
-} catch (Exiv2::AnyError& e) {
-    std::cout << "Caught Exiv2 exception '" << e << "'\n";
-    return -1;
 }

samples/xmpdump.cpp

@@ -7,26 +7,29 @@
 #include <string>
 #include "image.hpp"
 
-int main(int argc, char* const argv[]) try {
+int main(int argc, char* const argv[])
-    if (argc != 2) {
+{
-        std::cout << "Usage: " << argv[0] << " file\n";
+    try {
-        return 1;
+        if (argc != 2) {
-    }
+            std::cout << "Usage: " << argv[0] << " file\n";
+            return 1;
+        }
 
-    Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
+        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
-    assert(image.get() != 0);
+        assert(image.get() != 0);
-    image->readMetadata();
+        image->readMetadata();
 
-    const std::string& xmpPacket = image->xmpPacket();
+        const std::string& xmpPacket = image->xmpPacket();
-    if (xmpPacket.empty()) {
+        if (xmpPacket.empty()) {
-        std::string error(argv[1]);
+            std::string error(argv[1]);
-        error += ": No XMP packet found in the file";
+            error += ": No XMP packet found in the file";
-        throw Exiv2::Error(Exiv2::kerErrorMessage, error);
+            throw Exiv2::Error(Exiv2::kerErrorMessage, error);
-    }
+        }
-    std::cout << xmpPacket << "\n";
+        std::cout << xmpPacket << "\n";
 
-    return 0;
+        return 0;
-} catch (Exiv2::AnyError& e) {
+    } catch (Exiv2::AnyError& e) {
-    std::cout << "Caught Exiv2 exception '" << e << "'\n";
+        std::cout << "Caught Exiv2 exception '" << e << "'\n";
-    return -1;
+        return -1;
+    }
 }