introduce throwable_exit for nicer stack unwinding

yes, I enjoy abusing features

Signed-off-by: Michael Krelin <hacker@klever.net>

1 files changed, 5 insertions, 0 deletions

diff --git a/src/eyetil.h b/src/eyetil.h
index eff2c43..03b9ba8 100644
--- a/src/eyetil.h
+++ b/src/eyetil.h
@@ -1,57 +1,62 @@
 #ifndef __EYETIL_H
 #define __EYETIL_H
 
 #include <vector>
 #include <string>
 #include <archive.h>
 #include <archive_entry.h>
 #include "openssl/md5.h"
 
+struct throwable_exit {
+    int rc;
+    throwable_exit(int rc_) : rc(rc_) { }
+};
+
 class binary_t : public std::vector<unsigned char> {
     public:
         binary_t() { }
         binary_t(size_type  n) : std::vector<unsigned char>(n) { }
         binary_t(const std::string& h) { from_hex(h); }
         binary_t(const void *d,size_t s) { from_data(d,s); }
 
         binary_t& from_hex(const std::string& h);
         binary_t& from_data(const void *d,size_t s);
         binary_t& make_nonce();
 
         std::string hex() const;
         binary_t md5() const;
 };
 
 struct md5_digester {
     MD5_CTX ctx;
     md5_digester() { init(); }
 
     void init();
     void update(const void *d,size_t l);
     binary_t final();
 
     template<typename T>
     void update(const T& x) { update(&x,sizeof(x)); }
 
     template<typename T>
     struct update_iterator : public std::iterator<std::output_iterator_tag,T,void,T*,T&> {
         md5_digester *d;
         update_iterator(md5_digester *d_) : d(d_) { }
         update_iterator(const update_iterator& x) : d(x.d) { }
 
         update_iterator& operator*() { return *this; }
         update_iterator& operator++() { return *this; }
         update_iterator& operator++(int) { return *this; }
 
         update_iterator& operator=(const T& x) {
             d->update(x); return *this;
         }
     };
 
     template<typename T>
     update_iterator<T> updater() {
         return update_iterator<T>(this);
     }
 
 };
 template<> inline void md5_digester::update<binary_t>(const binary_t& x) {