diff --git a/lang/cpp/src/Makefile.am b/lang/cpp/src/Makefile.am
index 1e6bdc28..1b1de327 100644
--- a/lang/cpp/src/Makefile.am
+++ b/lang/cpp/src/Makefile.am
@@ -1,109 +1,110 @@
 # Makefile.am for GPGMEPP.
 # Copyright (C) 2016 Bundesamt für Sicherheit in der Informationstechnik
 # Software engineering by Intevation GmbH
 #
 # This file is part of GPGMEPP.
 #
 # GPGME-CL is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME-CL is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Lesser General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 # 02111-1307, USA
 
 EXTRA_DIST = GpgmeppConfig.cmake.in.in GpgmeppConfigVersion.cmake.in \
              gpgmepp_version.h.in GpgmeppConfig-w32.cmake.in.in
 
 lib_LTLIBRARIES = libgpgmepp.la
 
 main_sources = \
     exception.cpp context.cpp key.cpp trustitem.cpp data.cpp callbacks.cpp \
     eventloopinteractor.cpp editinteractor.cpp \
     keylistresult.cpp keygenerationresult.cpp importresult.cpp \
     decryptionresult.cpp verificationresult.cpp \
     signingresult.cpp encryptionresult.cpp \
     engineinfo.cpp gpgsetexpirytimeeditinteractor.cpp \
     gpgsetownertrusteditinteractor.cpp gpgsignkeyeditinteractor.cpp \
     gpgadduserideditinteractor.cpp gpggencardkeyinteractor.cpp \
     defaultassuantransaction.cpp \
     scdgetinfoassuantransaction.cpp gpgagentgetinfoassuantransaction.cpp \
     vfsmountresult.cpp configuration.cpp tofuinfo.cpp swdbresult.cpp
 
 gpgmepp_headers = \
     configuration.h context.h data.h decryptionresult.h \
     defaultassuantransaction.h editinteractor.h encryptionresult.h \
     engineinfo.h error.h eventloopinteractor.h exception.h global.h \
     gpgadduserideditinteractor.h gpgagentgetinfoassuantransaction.h \
     gpgmefw.h gpgsetexpirytimeeditinteractor.h \
     gpgsetownertrusteditinteractor.h gpgsignkeyeditinteractor.h \
     gpggencardkeyinteractor.h \
     importresult.h keygenerationresult.h key.h keylistresult.h \
     notation.h result.h scdgetinfoassuantransaction.h signingresult.h \
     trustitem.h verificationresult.h vfsmountresult.h gpgmepp_export.h \
     tofuinfo.h swdbresult.h
 
 private_gpgmepp_headers = \
     result_p.h context_p.h util.h callbacks.h data_p.h
 
 interface_headers= \
     interfaces/assuantransaction.h interfaces/dataprovider.h \
     interfaces/passphraseprovider.h interfaces/progressprovider.h
 
 gpgmeppincludedir = $(includedir)/gpgme++
 gpgmeppinclude_HEADERS = $(gpgmepp_headers)
 nobase_gpgmeppinclude_HEADERS = $(interface_headers)
 nodist_gpgmeppinclude_HEADERS = gpgmepp_version.h
 
 libgpgmepp_la_SOURCES = $(main_sources) $(gpgmepp_headers) context_vanilla.cpp \
                         $(interface_headers) $(private_gpgmepp_headers)
 
 AM_CPPFLAGS = -I$(top_builddir)/src @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ \
-              -DBUILDING_GPGMEPP
+              -DBUILDING_GPGMEPP -Wsuggest-override \
+              -Wzero-as-null-pointer-constant
 
 libgpgmepp_la_LIBADD = ../../../src/libgpgme.la @LIBASSUAN_LIBS@
 libgpgmepp_la_LDFLAGS = -no-undefined -version-info \
     @LIBGPGMEPP_LT_CURRENT@:@LIBGPGMEPP_LT_REVISION@:@LIBGPGMEPP_LT_AGE@
 
 if HAVE_MACOS_SYSTEM
 libsuffix=.dylib
 else
 libsuffix=.so
 endif
 
 if HAVE_W32_SYSTEM
 GpgmeppConfig.cmake: GpgmeppConfig-w32.cmake.in
 	sed -e 's|[@]resolved_bindir@|$(bindir)|g' < "$<" | \
 	sed -e 's|[@]resolved_libdir@|$(libdir)|g' | \
 	sed -e 's|[@]resolved_includedir@|$(includedir)|g' > $@
 else
 GpgmeppConfig.cmake: GpgmeppConfig.cmake.in
 	sed -e 's|[@]resolved_libdir@|$(libdir)|g' < "$<" | \
 	sed -e 's|[@]libsuffix@|$(libsuffix)|g' | \
 	sed -e 's|[@]resolved_includedir@|$(includedir)|g' > $@
 endif
 install-cmake-files: GpgmeppConfig.cmake GpgmeppConfigVersion.cmake
 	-$(INSTALL) -d $(DESTDIR)$(libdir)/cmake/Gpgmepp
 	$(INSTALL) -m 644 GpgmeppConfig.cmake \
         $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake
 	$(INSTALL) -m 644 GpgmeppConfigVersion.cmake \
         $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake
 
 uninstall-cmake-files:
 	-rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake
 	-rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake
 	-rmdir $(DESTDIR)$(libdir)/cmake/Gpgmepp/
 
 install-data-local: install-cmake-files
 
 uninstall-local: uninstall-cmake-files
 
 CLEANFILES = GpgmeppConfig.cmake GpgmeppConfigVersion.cmake \
              gpgmepp_version.h GpgmeppConfig.cmake.in
diff --git a/lang/cpp/src/callbacks.cpp b/lang/cpp/src/callbacks.cpp
index f7692a03..21c2a813 100644
--- a/lang/cpp/src/callbacks.cpp
+++ b/lang/cpp/src/callbacks.cpp
@@ -1,155 +1,155 @@
 /*
   callbacks.cpp - callback targets for internal use:
   Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "callbacks.h"
 #include "util.h"
 
 #include <interfaces/progressprovider.h>
 #include <interfaces/passphraseprovider.h>
 #include <interfaces/dataprovider.h>
 #include <error.h>
 
 #include <gpgme.h>
 #include <gpg-error.h>
 
 #include <cassert>
 #include <cerrno>
 #include <cstring>
 #include <unistd.h>
 #include <stdlib.h>
 
 static inline gpgme_error_t make_err_from_syserror()
 {
     return gpgme_error_from_syserror();
 }
 
 using GpgME::ProgressProvider;
 using GpgME::PassphraseProvider;
 using GpgME::DataProvider;
 
 void progress_callback(void *opaque, const char *what,
                        int type, int current, int total)
 {
     ProgressProvider *provider = static_cast<ProgressProvider *>(opaque);
     if (provider) {
         provider->showProgress(what, type, current, total);
     }
 }
 
 /* To avoid that a compiler optimizes certain memset calls away, these
    macros may be used instead. */
 #define wipememory2(_ptr,_set,_len) do { \
         volatile char *_vptr=(volatile char *)(_ptr); \
         size_t _vlen=(_len); \
         while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \
     } while(0)
 #define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
 
 gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint, const char *desc,
                                   int prev_was_bad, int fd)
 {
     PassphraseProvider *provider = static_cast<PassphraseProvider *>(opaque);
     bool canceled = false;
     gpgme_error_t err = GPG_ERR_NO_ERROR;
-    char *passphrase = provider ? provider->getPassphrase(uid_hint, desc, prev_was_bad, canceled) : 0 ;
+    char *passphrase = provider ? provider->getPassphrase(uid_hint, desc, prev_was_bad, canceled) : nullptr ;
     if (canceled) {
         err = make_error(GPG_ERR_CANCELED);
     } else {
         if (passphrase && *passphrase) {
             size_t passphrase_length = std::strlen(passphrase);
             size_t written = 0;
             do {
                 ssize_t now_written = gpgme_io_write(fd, passphrase + written, passphrase_length - written);
                 if (now_written < 0) {
                     err = make_err_from_syserror();
                     break;
                 }
                 written += now_written;
             } while (written < passphrase_length);
         }
     }
 
     if (passphrase && *passphrase) {
         wipememory(passphrase, std::strlen(passphrase));
     }
     free(passphrase);
     gpgme_io_write(fd, "\n", 1);
     return err;
 }
 
 static gpgme_ssize_t
 data_read_callback(void *opaque, void *buf, size_t buflen)
 {
     DataProvider *provider = static_cast<DataProvider *>(opaque);
     if (!provider) {
         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
         return -1;
     }
     return (gpgme_ssize_t)provider->read(buf, buflen);
 }
 
 static gpgme_ssize_t
 data_write_callback(void *opaque, const void *buf, size_t buflen)
 {
     DataProvider *provider = static_cast<DataProvider *>(opaque);
     if (!provider) {
         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
         return -1;
     }
     return (gpgme_ssize_t)provider->write(buf, buflen);
 }
 
 static gpgme_off_t
 data_seek_callback(void *opaque, gpgme_off_t offset, int whence)
 {
     DataProvider *provider = static_cast<DataProvider *>(opaque);
     if (!provider) {
         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
         return -1;
     }
     if (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) {
         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
         return -1;
     }
     return provider->seek((off_t)offset, whence);
 }
 
 static void data_release_callback(void *opaque)
 {
     DataProvider *provider = static_cast<DataProvider *>(opaque);
     if (provider) {
         provider->release();
     }
 }
 
 const gpgme_data_cbs GpgME::data_provider_callbacks = {
     &data_read_callback,
     &data_write_callback,
     &data_seek_callback,
     &data_release_callback
 };
diff --git a/lang/cpp/src/configuration.cpp b/lang/cpp/src/configuration.cpp
index 8ccc05e9..33c812f7 100644
--- a/lang/cpp/src/configuration.cpp
+++ b/lang/cpp/src/configuration.cpp
@@ -1,940 +1,940 @@
 /*
   configuration.cpp - wraps gpgme configuration components
   Copyright (C) 2010 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "configuration.h"
 #include "error.h"
 #include "util.h"
 
 #include <gpgme.h>
 
 #include <iterator>
 #include <algorithm>
 #include <ostream>
 #include <cstring>
 #include <assert.h>
 
 using namespace GpgME;
 using namespace GpgME::Configuration;
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_conf_opt_t>::type > shared_gpgme_conf_opt_t;
 typedef std::weak_ptr< std::remove_pointer<gpgme_conf_opt_t>::type > weak_gpgme_conf_opt_t;
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_conf_arg_t>::type > shared_gpgme_conf_arg_t;
 typedef std::weak_ptr< std::remove_pointer<gpgme_conf_arg_t>::type > weak_gpgme_conf_arg_t;
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_ctx_t>::type > shared_gpgme_ctx_t;
 typedef std::weak_ptr< std::remove_pointer<gpgme_ctx_t>::type > weak_gpgme_ctx_t;
 
 namespace
 {
 struct nodelete {
     template <typename T> void operator()(T *) {}
 };
 }
 
 // static
 std::vector<Component> Component::load(Error &returnedError)
 {
 
     //
     // 1. get a context:
     //
-    gpgme_ctx_t ctx_native = 0;
+    gpgme_ctx_t ctx_native = nullptr;
     if (const gpgme_error_t err = gpgme_new(&ctx_native)) {
         returnedError = Error(err);
         return std::vector<Component>();
     }
     const shared_gpgme_ctx_t ctx(ctx_native, &gpgme_release);
 
     //
     // 2. load the config:
     //
-    gpgme_conf_comp_t conf_list_native = 0;
+    gpgme_conf_comp_t conf_list_native = nullptr;
     if (const gpgme_error_t err = gpgme_op_conf_load(ctx_native, &conf_list_native)) {
         returnedError = Error(err);
         return std::vector<Component>();
     }
     shared_gpgme_conf_comp_t head(conf_list_native, &gpgme_conf_release);
 
     //
     // 3. convert to vector<Component>:
     //
     std::vector<Component> result;
 
     while (head) {
         // secure 'head->next' (if any) against memleaks:
         shared_gpgme_conf_comp_t next;
         if (head->next) {
             next.reset(head->next, &gpgme_conf_release);
         }
 
         // now prevent double-free of next.get() and following:
-        head->next = 0;
+        head->next = nullptr;
 
         // now add a new Component to 'result' (may throw):
         result.resize(result.size() + 1);
         result.back().comp.swap(head);   // .comp = std::move( head );
         head.swap(next);                 //  head = std::move( next );
     }
 
     return result;
 }
 
 Error Component::save() const
 {
 
     if (isNull()) {
         return Error(make_error(GPG_ERR_INV_ARG));
     }
 
     //
     // 1. get a context:
     //
-    gpgme_ctx_t ctx_native = 0;
+    gpgme_ctx_t ctx_native = nullptr;
     if (const gpgme_error_t err = gpgme_new(&ctx_native)) {
         return Error(err);
     }
     const shared_gpgme_ctx_t ctx(ctx_native, &gpgme_release);
 
     //
     // 2. save the config:
     //
     return Error(gpgme_op_conf_save(ctx.get(), comp.get()));
 }
 
 const char *Component::name() const
 {
-    return comp ? comp->name : 0 ;
+    return comp ? comp->name : nullptr;
 }
 
 const char *Component::description() const
 {
-    return comp ? comp->description : 0 ;
+    return comp ? comp->description : nullptr ;
 }
 
 const char *Component::programName() const
 {
-    return comp ? comp->program_name : 0 ;
+    return comp ? comp->program_name : nullptr ;
 }
 
 Option Component::option(unsigned int idx) const
 {
-    gpgme_conf_opt_t opt = 0;
+    gpgme_conf_opt_t opt = nullptr;
     if (comp) {
         opt = comp->options;
     }
     while (opt && idx) {
         opt = opt->next;
         --idx;
     }
     if (opt) {
         return Option(comp, opt);
     }
     return Option();
 }
 
 Option Component::option(const char *name) const
 {
-    gpgme_conf_opt_t opt = 0;
+    gpgme_conf_opt_t opt = nullptr;
     if (comp) {
         opt = comp->options;
     }
     using namespace std; // for strcmp
     while (opt && strcmp(name, opt->name) != 0) {
         opt = opt->next;
     }
     if (opt) {
         return Option(comp, opt);
     }
     return Option();
 }
 
 unsigned int Component::numOptions() const
 {
     unsigned int result = 0;
-    for (gpgme_conf_opt_t opt = comp ? comp->options : 0 ; opt ; opt = opt->next) {
+    for (gpgme_conf_opt_t opt = comp ? comp->options : nullptr ; opt ; opt = opt->next) {
         ++result;
     }
     return result;
 }
 
 std::vector<Option> Component::options() const
 {
     std::vector<Option> result;
-    for (gpgme_conf_opt_t opt = comp ? comp->options : 0 ; opt ; opt = opt->next) {
+    for (gpgme_conf_opt_t opt = comp ? comp->options : nullptr ; opt ; opt = opt->next) {
         result.push_back(Option(comp, opt));
     }
     return result;
 }
 
 static gpgme_conf_arg_t mygpgme_conf_arg_copy(gpgme_conf_arg_t other, gpgme_conf_type_t type)
 {
-    gpgme_conf_arg_t result = 0, last = 0;
+    gpgme_conf_arg_t result = nullptr, last = nullptr;
     for (gpgme_conf_arg_t a = other ; a ; a = a->next) {
-        gpgme_conf_arg_t arg = 0;
+        gpgme_conf_arg_t arg = nullptr;
         const gpgme_error_t err
             = gpgme_conf_arg_new(&arg, type,
-                                 a->no_arg                 ? 0 :
+                                 a->no_arg                 ? nullptr :
                                  type == GPGME_CONF_STRING ? a->value.string :
                                  /* else */                  static_cast<void *>(&a->value));
         if (err) {
             gpgme_conf_arg_release(result, type);
-            return 0;
+            return nullptr;
         }
         assert(arg);
         if (result) {
             last->next = arg;
         } else {
             result = arg;
         }
         last = arg;
     }
     return result;
 }
 
 Component Option::parent() const
 {
     return Component(comp.lock());
 }
 
 unsigned int Option::flags() const
 {
     return isNull() ? 0 : opt->flags;
 }
 
 Level Option::level() const
 {
     return isNull() ? Internal : static_cast<Level>(opt->level) ;
 }
 
 const char *Option::name() const
 {
-    return isNull() ? 0 : opt->name ;
+    return isNull() ? nullptr : opt->name ;
 }
 
 const char *Option::description() const
 {
-    return isNull() ? 0 : opt->description ;
+    return isNull() ? nullptr : opt->description ;
 }
 
 const char *Option::argumentName() const
 {
-    return isNull() ? 0 : opt->argname ;
+    return isNull() ? nullptr : opt->argname ;
 }
 
 Type Option::type() const
 {
     return isNull() ? NoType : static_cast<Type>(opt->type) ;
 }
 
 Type Option::alternateType() const
 {
     return isNull() ? NoType : static_cast<Type>(opt->alt_type) ;
 }
 
 #if 0
 static Option::Variant argument_to_variant(gpgme_conf_type_t type, bool list, gpgme_conf_arg_t arg)
 {
     assert(arg);
     switch (type) {
     case GPGME_CONF_NONE:
         if (list) {
             // return the count (number of times set):
             return arg->value.count;
         } else {
             return none;
         }
     case GPGME_CONF_INT32:
         if (list) {
             std::vector<int> result;
             for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
                 result.push_back(a->value.int32);
             }
             return result;
         } else {
             return arg->value.int32;
         }
     case GPGME_CONF_UINT32:
         if (list) {
             std::vector<unsigned int> result;
             for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
                 result.push_back(a->value.uint32);
             }
             return result;
         } else {
             return arg->value.uint32;
         }
     case GPGME_CONF_FILENAME:
     case GPGME_CONF_LDAP_SERVER:
     case GPGME_CONF_KEY_FPR:
     case GPGME_CONF_PUB_KEY:
     case GPGME_CONF_SEC_KEY:
     case GPGME_CONF_ALIAS_LIST:
     // these should not happen in alt_type, but fall through
     case GPGME_CONF_STRING:
         if (list) {
             std::vector<const char *> result;
             for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
                 result.push_back(a->value.string);
             }
             return result;
         } else {
             return arg->value.string;
         }
     }
     assert(!"Option: unknown alt_type!");
     return Option::Variant();
 }
 
 namespace
 {
 inline const void *to_void_star(const char *s)
 {
     return s;
 }
 inline const void *to_void_star(const std::string &s)
 {
     return s.c_str();
 }
 inline const void *to_void_star(const int &i)
 {
     return &i;    // const-&: sic!
 }
 inline const void *to_void_star(const unsigned int &i)
 {
     return &i;    // const-&: sic!
 }
 
 struct VariantToArgumentVisitor : boost::static_visitor<gpgme_conf_arg_t> {
     static gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const void *value)
     {
         gpgme_conf_arg_t arg = 0;
 #ifdef HAVE_GPGME_CONF_ARG_NEW_WITH_CONST_VALUE
         if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, value)) {
             return 0;
         }
 #else
         if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, const_cast<void *>(value))) {
             return 0;
         }
 #endif
         else {
             return arg;
         }
     }
 
     gpgme_conf_arg_t operator()(bool v) const
     {
         return v ? make_argument(0) : 0 ;
     }
 
     gpgme_conf_arg_t operator()(const char *s) const
     {
         return make_argument(s ? s : "");
     }
 
     gpgme_conf_arg_t operator()(const std::string &s) const
     {
         return operator()(s.c_str());
     }
 
     gpgme_conf_arg_t operator()(int i) const
     {
         return make_argument(&i);
     }
 
     gpgme_conf_arg_t operator()(unsigned int i) const
     {
         return make_argument(&i);
     }
 
     template <typename T>
     gpgme_conf_arg_t operator()(const std::vector<T> &value) const
     {
         gpgme_conf_arg_t result = 0;
         gpgme_conf_arg_t last = 0;
         for (typename std::vector<T>::const_iterator it = value.begin(), end = value.end() ; it != end ; ++it) {
             if (gpgme_conf_arg_t arg = make_argument(to_void_star(*it))) {
                 if (last) {
                     last = last->next = arg;
                 } else {
                     result = last = arg;
                 }
             }
         }
         return result;
     }
 
 };
 }
 
 static gpgme_conf_arg_t variant_to_argument(const Option::Variant &value)
 {
     VariantToArgumentVisitor v;
     return apply_visitor(v, value);
 }
 
 optional<Option::Variant> Option::defaultValue() const
 {
     if (isNull()) {
         return optional<Variant>();
     } else {
         return argument_to_variant(opt->alt_type, opt->flags & GPGME_CONF_LIST, opt->default_value);
     }
 }
 #endif
 
 Argument Option::defaultValue() const
 {
     if (isNull()) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, opt->default_value, false);
     }
 }
 
 const char *Option::defaultDescription() const
 {
-    return isNull() ? 0 : opt->default_description ;
+    return isNull() ? nullptr : opt->default_description ;
 }
 
 Argument Option::noArgumentValue() const
 {
     if (isNull()) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, opt->no_arg_value, false);
     }
 }
 
 const char *Option::noArgumentDescription() const
 {
-    return isNull() ? 0 : opt->no_arg_description ;
+    return isNull() ? nullptr : opt->no_arg_description ;
 }
 
 Argument Option::activeValue() const
 {
     if (isNull()) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, opt->value, false);
     }
 }
 
 Argument Option::currentValue() const
 {
     if (isNull()) {
         return Argument();
     }
     const gpgme_conf_arg_t arg =
         opt->change_value ? opt->new_value ? opt->new_value : opt->default_value :
         opt->value        ? opt->value :
         /* else */          opt->default_value ;
     return Argument(comp.lock(), opt, arg, false);
 }
 
 Argument Option::newValue() const
 {
     if (isNull()) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, opt->new_value, false);
     }
 }
 
 bool Option::set() const
 {
     if (isNull()) {
         return false;
     } else if (opt->change_value) {
         return opt->new_value;
     } else {
         return opt->value;
     }
 }
 
 bool Option::dirty() const
 {
     return !isNull() && opt->change_value ;
 }
 
 Error Option::setNewValue(const Argument &argument)
 {
     if (isNull()) {
         return Error(make_error(GPG_ERR_INV_ARG));
     } else if (argument.isNull()) {
         return resetToDefaultValue();
     } else if (const gpgme_conf_arg_t arg = mygpgme_conf_arg_copy(argument.arg, opt->alt_type)) {
         return Error(gpgme_conf_opt_change(opt, 0, arg));
     } else {
         return Error(make_error(GPG_ERR_ENOMEM));
     }
 }
 
 Error Option::resetToActiveValue()
 {
     if (isNull()) {
         return Error(make_error(GPG_ERR_INV_ARG));
     } else {
-        return Error(gpgme_conf_opt_change(opt, 1, 0));
+        return Error(gpgme_conf_opt_change(opt, 1, nullptr));
     }
 }
 
 Error Option::resetToDefaultValue()
 {
     if (isNull()) {
         return Error(make_error(GPG_ERR_INV_ARG));
     } else {
-        return Error(gpgme_conf_opt_change(opt, 0, 0));
+        return Error(gpgme_conf_opt_change(opt, 0, nullptr));
     }
 }
 
 static gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const void *value)
 {
-    gpgme_conf_arg_t arg = 0;
+    gpgme_conf_arg_t arg = nullptr;
     if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, value)) {
-        return 0;
+        return nullptr;
     } else {
         return arg;
     }
 }
 
 Argument Option::createNoneArgument(bool set) const
 {
     if (isNull() || alternateType() != NoType) {
         return Argument();
     } else {
         if (set) {
             return createNoneListArgument(1);
         }
     }
     return Argument();
 }
 
 Argument Option::createStringArgument(const char *value) const
 {
     if (isNull() || alternateType() != StringType) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true);
     }
 }
 
 Argument Option::createStringArgument(const std::string &value) const
 {
     if (isNull() || alternateType() != StringType) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value.c_str()), true);
     }
 }
 
 Argument Option::createIntArgument(int value) const
 {
     if (isNull() || alternateType() != IntegerType) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, make_argument(GPGME_CONF_INT32, &value), true);
     }
 }
 
 Argument Option::createUIntArgument(unsigned int value) const
 {
     if (isNull() || alternateType() != UnsignedIntegerType) {
         return Argument();
     } else {
         return Argument(comp.lock(), opt, make_argument(GPGME_CONF_UINT32, &value), true);
     }
 }
 
 namespace
 {
 const void *to_void_star(const char *s)
 {
     return s;
 }
 const void *to_void_star(const std::string &s)
 {
     return s.c_str();
 }
 const void *to_void_star(const int &i)
 {
     return &i;    // const-&: sic!
 }
 const void *to_void_star(const unsigned int &i)
 {
     return &i;    // const-&: sic!
 }
 
 template <typename T>
 gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const std::vector<T> &value)
 {
-    gpgme_conf_arg_t result = 0;
-    gpgme_conf_arg_t last = 0;
+    gpgme_conf_arg_t result = nullptr;
+    gpgme_conf_arg_t last = nullptr;
     for (typename std::vector<T>::const_iterator it = value.begin(), end = value.end() ; it != end ; ++it) {
         if (gpgme_conf_arg_t arg = make_argument(type, to_void_star(*it))) {
             if (last) {
                 last = last->next = arg;
             } else {
                 result = last = arg;
             }
         }
     }
     return result;
 }
 }
 
 Argument Option::createNoneListArgument(unsigned int value) const
 {
     if (value) {
         return Argument(comp.lock(), opt, make_argument(GPGME_CONF_NONE, &value), true);
     }
     return Argument();
 }
 
 Argument Option::createStringListArgument(const std::vector<const char *> &value) const
 {
     return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true);
 }
 
 Argument Option::createStringListArgument(const std::vector<std::string> &value) const
 {
     return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true);
 }
 
 Argument Option::createIntListArgument(const std::vector<int> &value) const
 {
     return Argument(comp.lock(), opt, make_argument(GPGME_CONF_INT32, value), true);
 }
 
 Argument Option::createUIntListArgument(const std::vector<unsigned int> &value) const
 {
     return Argument(comp.lock(), opt, make_argument(GPGME_CONF_UINT32, value), true);
 }
 
 Argument::Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns)
     : comp(comp),
       opt(opt),
       arg(owns ? arg : mygpgme_conf_arg_copy(arg, opt ? opt->alt_type : GPGME_CONF_NONE))
 {
 
 }
 
 #if 0
 Argument::Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg)
     : comp(comp),
       opt(opt),
       arg(mygpgme_conf_arg_copy(arg, opt ? opt->alt_type : GPGME_CONF_NONE))
 {
 
 }
 #endif
 
 Argument::Argument(const Argument &other)
     : comp(other.comp),
       opt(other.opt),
       arg(mygpgme_conf_arg_copy(other.arg, opt ? opt->alt_type : GPGME_CONF_NONE))
 {
 
 }
 
 Argument::~Argument()
 {
     gpgme_conf_arg_release(arg, opt ? opt->alt_type : GPGME_CONF_NONE);
 }
 
 Option Argument::parent() const
 {
     return Option(comp.lock(), opt);
 }
 
 bool Argument::boolValue() const
 {
     return numberOfTimesSet();
 }
 
 unsigned int Argument::numElements() const
 {
     if (isNull()) {
         return 0;
     }
     unsigned int result = 0;
     for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
         ++result;
     }
     return result;
 }
 
 const char *Argument::stringValue(unsigned int idx) const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_STRING) {
-        return 0;
+        return nullptr;
     }
     gpgme_conf_arg_t a = arg;
     while (a && idx) {
         a = a->next;
         --idx;
     }
-    return a ? a->value.string : 0 ;
+    return a ? a->value.string : nullptr ;
 }
 
 int Argument::intValue(unsigned int idx) const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_INT32) {
         return 0;
     }
     gpgme_conf_arg_t a = arg;
     while (a && idx) {
         a = a->next;
         --idx;
     }
     return a ? a->value.int32 : 0 ;
 }
 
 unsigned int Argument::uintValue(unsigned int idx) const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_UINT32) {
         return 0;
     }
     gpgme_conf_arg_t a = arg;
     while (a && idx) {
         a = a->next;
         --idx;
     }
     return a ? a->value.uint32 : 0 ;
 }
 
 unsigned int Argument::numberOfTimesSet() const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_NONE) {
         return 0;
     }
     return arg->value.count;
 }
 
 std::vector<const char *> Argument::stringValues() const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_STRING) {
         return std::vector<const char *>();
     }
     std::vector<const char *> result;
     for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
         result.push_back(a->value.string);
     }
     return result;
 }
 
 std::vector<int> Argument::intValues() const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_INT32) {
         return std::vector<int>();
     }
     std::vector<int> result;
     for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
         result.push_back(a->value.int32);
     }
     return result;
 }
 
 std::vector<unsigned int> Argument::uintValues() const
 {
     if (isNull() || opt->alt_type != GPGME_CONF_UINT32) {
         return std::vector<unsigned int>();
     }
     std::vector<unsigned int> result;
     for (gpgme_conf_arg_t a = arg ; a ; a = a->next) {
         result.push_back(a->value.uint32);
     }
     return result;
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, Level level)
 {
     switch (level) {
     case Basic:     return os << "Basic";
     case Advanced:  return os << "Advanced";
     case Expert:    return os << "Expert";
     case Invisible: return os << "Invisible";
     case Internal:  return os << "Internal";
     case NumLevels: ;
     }
     return os << "<unknown>";
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, Type type)
 {
     switch (type) {
     case NoType:              return os << "None";
     case StringType:          return os << "String";
     case IntegerType:         return os << "Integer";
     case UnsignedIntegerType: return os << "UnsignedInteger";
     case FilenameType:        return os << "Filename";
     case LdapServerType:      return os << "LdapServer";
     case KeyFingerprintType:  return os << "KeyFingerprint";
     case PublicKeyType:       return os << "PublicKey";
     case SecretKeyType:       return os << "SecretKey";
     case AliasListType:       return os << "AliasList";
     case MaxType: ;
     }
     return os << "<unknown>";
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, Flag f)
 {
     unsigned int flags = f;
     std::vector<const char *> s;
     if (flags & Group) {
         s.push_back("Group");
     }
     if (flags & Optional) {
         s.push_back("Optional");
     }
     if (flags & List) {
         s.push_back("List");
     }
     if (flags & Runtime) {
         s.push_back("Runtime");
     }
     if (flags & Default) {
         s.push_back("Default");
     }
     if (flags & DefaultDescription) {
         s.push_back("DefaultDescription");
     }
     if (flags & NoArgumentDescription) {
         s.push_back("NoArgumentDescription");
     }
     if (flags & NoChange) {
         s.push_back("NoChange");
     }
     flags &= ~(Group | Optional | List | Runtime | Default | DefaultDescription | NoArgumentDescription | NoChange);
     if (flags) {
         s.push_back("other flags(");
     }
     std::copy(s.begin(), s.end(),
               std::ostream_iterator<const char *>(os, "|"));
     if (flags) {
         os << flags << ')';
     }
     return os;
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, const Component &c)
 {
     os << "Component["
        << "\n  name       : " << protect(c.name())
        << "\n  description: " << protect(c.description())
        << "\n  programName: " << protect(c.programName())
        << "\n  options    : \n";
     const std::vector<Option> options = c.options();
     std::copy(options.begin(), options.end(),
               std::ostream_iterator<Option>(os, "\n"));
     os << "\n]";
     return os;
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, const Option &o)
 {
     return os << "Option["
            << "\n  name:       : " << protect(o.name())
            << "\n  description : " << protect(o.description())
            << "\n  argName     : " << protect(o.argumentName())
            << "\n  flags       : " << static_cast<Flag>(o.flags())
            << "\n  level       : " << o.level()
            << "\n  type        : " << o.type()
            << "\n  alt_type    : " << o.alternateType()
            << "\n  default_val : " << o.defaultValue()
            << "\n  default_desc: " << protect(o.defaultDescription())
            << "\n  no_arg_value: " << o.noArgumentValue()
            << "\n  no_arg_desc : " << protect(o.noArgumentDescription())
            << "\n  active_value: " << o.activeValue()
            << "\n  new_value   : " << o.newValue()
            << "\n  --> cur_val : " << o.currentValue()
            << "\n  set         : " << o.set()
            << "\n  dirty       : " << o.dirty()
            << "\n]"
            ;
 }
 
 std::ostream &Configuration::operator<<(std::ostream &os, const Argument &a)
 {
     const Option o = a.parent();
     const bool list = o.flags() & List;
     os << "Argument[";
     if (a) {
         switch (o.alternateType()) {
         case NoType:
             if (list) {
                 os << a.numberOfTimesSet() << 'x';
             } else {
                 os << a.boolValue();
             }
             break;
         default:
         case StringType:
             if (list) {
                 const std::vector<const char *> v = a.stringValues();
                 os << v.size() << ':';
                 // can't use std::copy + ostream_iterator here, since we need the protect() call
                 bool first = true;
                 std::for_each(v.begin(), v.end(), [&first, &os](const char *s) {
                     if (first) {
                         first = false;
                     } else {
                         os << ',';
                     }
                     os << protect(s);
                 });
             } else {
                 os << protect(a.stringValue());
             }
             break;
         case IntegerType:
             if (list) {
                 const std::vector<int> v = a.intValues();
                 os << v.size() << ':';
                 std::copy(v.begin(), v.end(),
                           std::ostream_iterator<int>(os, ","));
             } else {
                 os << a.intValue();
             }
             break;
         case UnsignedIntegerType:
             if (list) {
                 const std::vector<unsigned int> v = a.uintValues();
                 os << v.size() << ':';
                 std::copy(v.begin(), v.end(),
                           std::ostream_iterator<unsigned int>(os, ","));
             } else {
                 os << a.intValue();
             }
             break;
         }
     }
     return os << ']';
 }
diff --git a/lang/cpp/src/configuration.h b/lang/cpp/src/configuration.h
index 6993b6dd..2e577156 100644
--- a/lang/cpp/src/configuration.h
+++ b/lang/cpp/src/configuration.h
@@ -1,292 +1,292 @@
 /*
   configuration.h - wraps gpgme configuration components
   Copyright (C) 2010 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_CONFIGURATION_H__
 #define __GPGMEPP_CONFIGURATION_H__
 
 #include "global.h"
 
 #include "gpgmefw.h"
 
 #include <iosfwd>
 #include <vector>
 #include <string>
 #include <algorithm>
 #include <memory>
 
 namespace GpgME
 {
 namespace Configuration
 {
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > shared_gpgme_conf_comp_t;
 typedef std::weak_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > weak_gpgme_conf_comp_t;
 
 class Argument;
 class Option;
 class Component;
 
 enum Level {
     Basic,
     Advanced,
     Expert,
     Invisible,
     Internal,
 
     NumLevels
 };
 
 enum Type {
     NoType,
     StringType,
     IntegerType,
     UnsignedIntegerType,
 
     FilenameType = 32,
     LdapServerType,
     KeyFingerprintType,
     PublicKeyType,
     SecretKeyType,
     AliasListType,
 
     MaxType
 };
 
 enum Flag {
     Group    = (1 << 0),
     Optional = (1 << 1),
     List     = (1 << 2),
     Runtime  = (1 << 3),
     Default  = (1 << 4),
     DefaultDescription = (1 << 5),
     NoArgumentDescription = (1 << 6),
     NoChange = (1 << 7),
 
     LastFlag = NoChange
 };
 
 //
 // class Component
 //
 
 class GPGMEPP_EXPORT Component
 {
 public:
     Component() : comp() {}
     explicit Component(const shared_gpgme_conf_comp_t &gpgme_comp)
         : comp(gpgme_comp) {}
 
     // copy ctor is ok
 
     const Component &operator=(const Component &other)
     {
         if (this != &other) {
             Component(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Component &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
     }
 
     bool isNull() const
     {
         return !comp;
     }
 
     static std::vector<Component> load(Error &err);
     Error save() const;
 
     const char *name() const;
     const char *description() const;
     const char *programName() const;
 
     Option option(unsigned int index) const;
     Option option(const char *name) const;
 
     unsigned int numOptions() const;
 
     std::vector<Option> options() const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     shared_gpgme_conf_comp_t comp;
 };
 
 //
 // class Option
 //
 
 class GPGMEPP_EXPORT Option
 {
 public:
-    Option() : comp(), opt(0) {}
+    Option() : comp(), opt(nullptr) {}
     Option(const shared_gpgme_conf_comp_t &gpgme_comp, gpgme_conf_opt_t gpgme_opt)
         : comp(gpgme_comp), opt(gpgme_opt) {}
 
     const Option &operator=(const Option &other)
     {
         if (this != &other) {
             Option(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Option &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
         swap(this->opt,  other.opt);
     }
 
     bool isNull() const
     {
         return comp.expired() || !opt;
     }
 
     Component parent() const;
 
     unsigned int flags() const;
 
     Level level() const;
 
     const char *name() const;
     const char *description() const;
     const char *argumentName() const;
 
     Type type() const;
     Type alternateType() const;
 
     Argument defaultValue() const;
     const char *defaultDescription() const;
 
     Argument noArgumentValue() const;
     const char *noArgumentDescription() const;
 
     /*! The value that is in the config file (or null, if it's not set). */
     Argument activeValue() const;
     /*! The value that is in this object, ie. either activeValue(), newValue(), or defaultValue() */
     Argument currentValue() const;
 
     Argument newValue() const;
     bool set() const;
     bool dirty() const;
 
     Error setNewValue(const Argument &argument);
     Error resetToDefaultValue();
     Error resetToActiveValue();
 
     Argument createNoneArgument(bool set) const;
     Argument createStringArgument(const char *value) const;
     Argument createStringArgument(const std::string &value) const;
     Argument createIntArgument(int value) const;
     Argument createUIntArgument(unsigned int value) const;
 
     Argument createNoneListArgument(unsigned int count) const;
     Argument createStringListArgument(const std::vector<const char *> &value) const;
     Argument createStringListArgument(const std::vector<std::string> &value) const;
     Argument createIntListArgument(const std::vector<int> &values) const;
     Argument createUIntListArgument(const std::vector<unsigned int> &values) const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     weak_gpgme_conf_comp_t  comp;
     gpgme_conf_opt_t opt;
 };
 
 //
 // class Argument
 //
 
 class GPGMEPP_EXPORT Argument
 {
     friend class ::GpgME::Configuration::Option;
     Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns);
 public:
-    Argument() : comp(), opt(0), arg(0) {}
+    Argument() : comp(), opt(nullptr), arg(nullptr) {}
     //Argument( const shared_gpgme_conf_comp_t & comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg );
     Argument(const Argument &other);
     ~Argument();
 
     const Argument &operator=(const Argument &other)
     {
         if (this != &other) {
             Argument(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Argument &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
         swap(this->opt,  other.opt);
         swap(this->arg,  other.arg);
     }
 
     bool isNull() const
     {
         return comp.expired() || !opt || !arg;
     }
 
     Option parent() const;
 
     unsigned int numElements() const;
 
     bool boolValue() const;
     const char *stringValue(unsigned int index = 0) const;
     int          intValue(unsigned int index = 0) const;
     unsigned int uintValue(unsigned int index = 0) const;
 
     unsigned int numberOfTimesSet() const;
     std::vector<const char *> stringValues() const;
     std::vector<int>          intValues() const;
     std::vector<unsigned int> uintValues() const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     weak_gpgme_conf_comp_t comp;
     gpgme_conf_opt_t opt;
     gpgme_conf_arg_t arg;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Level level);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Type type);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Flag flag);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Component &component);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Option &option);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Argument &argument);
 
 } // namespace Configuration
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Component)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Option)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Argument)
 
 #endif // __GPGMEPP_CONFIGURATION_H__
diff --git a/lang/cpp/src/context.cpp b/lang/cpp/src/context.cpp
index ce38db0b..1e8d8f09 100644
--- a/lang/cpp/src/context.cpp
+++ b/lang/cpp/src/context.cpp
@@ -1,1792 +1,1793 @@
 /*
   context.cpp - wraps a gpgme key context
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
+                2017, 2018 Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <context.h>
 #include <eventloopinteractor.h>
 #include <trustitem.h>
 #include <keylistresult.h>
 #include <keygenerationresult.h>
 #include <importresult.h>
 #include <decryptionresult.h>
 #include <verificationresult.h>
 #include <signingresult.h>
 #include <encryptionresult.h>
 #include <engineinfo.h>
 #include <editinteractor.h>
 #include <vfsmountresult.h>
 
 #include <interfaces/assuantransaction.h>
 #include <defaultassuantransaction.h>
 
 #include "callbacks.h"
 #include "data_p.h"
 #include "context_p.h"
 #include "util.h"
 #include "tofuinfo.h"
 
 #include <gpgme.h>
 
 #include <istream>
 #ifndef NDEBUG
 #include <iostream>
 using std::cerr;
 using std::endl;
 #endif
 
 #include <cassert>
 
 namespace GpgME
 {
 
 static inline unsigned int xtoi_1(const char *str)
 {
     const unsigned int ch = *str;
     const unsigned int result =
         ch <= '9' ? ch - '0' :
         ch <= 'F' ? ch - 'A' + 10 :
         /* else */  ch - 'a' + 10 ;
     return result < 16 ? result : 0 ;
 }
 static inline int xtoi_2(const char *str)
 {
     return xtoi_1(str) * 16U + xtoi_1(str + 1);
 }
 
 static void percent_unescape(std::string &s, bool plus2space)
 {
     std::string::iterator src = s.begin(), dest = s.begin(), end = s.end();
     while (src != end) {
         if (*src == '%' && end - src > 2) {
             *dest++ = xtoi_2(&*++src);
             src += 2;
         } else if (*src == '+' && plus2space) {
             *dest++ = ' ';
             ++src;
         } else {
             *dest++ = *src++;
         }
     }
     s.erase(dest, end);
 }
 
 void initializeLibrary()
 {
-    gpgme_check_version(0);
+    gpgme_check_version(nullptr);
 }
 
 Error initializeLibrary(int)
 {
     if (gpgme_check_version(GPGME_VERSION)) {
         return Error();
     } else {
         return Error::fromCode(GPG_ERR_USER_1);
     }
 }
 
 static void format_error(gpgme_error_t err, std::string &str)
 {
     char buffer[ 1024 ];
     gpgme_strerror_r(err, buffer, sizeof buffer);
     buffer[ sizeof buffer - 1 ] = '\0';
     str = buffer;
 }
 
 const char *Error::source() const
 {
     return gpgme_strsource((gpgme_error_t)mErr);
 }
 
 const char *Error::asString() const
 {
     if (mMessage.empty()) {
         format_error(static_cast<gpgme_error_t>(mErr), mMessage);
     }
     return mMessage.c_str();
 }
 
 int Error::code() const
 {
     return gpgme_err_code(mErr);
 }
 
 int Error::sourceID() const
 {
     return gpgme_err_source(mErr);
 }
 
 bool Error::isCanceled() const
 {
     return code() == GPG_ERR_CANCELED;
 }
 
 int Error::toErrno() const
 {
 //#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
     return gpgme_err_code_to_errno(static_cast<gpgme_err_code_t>(code()));
 //#else
 //    return gpg_err_code_to_errno( static_cast<gpg_err_code_t>( code() ) );
 //#endif
 }
 
 // static
 bool Error::hasSystemError()
 {
     return gpgme_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ;
 }
 
 // static
 void Error::setSystemError(gpg_err_code_t err)
 {
     setErrno(gpgme_err_code_to_errno(err));
 }
 
 // static
 void Error::setErrno(int err)
 {
     gpgme_err_set_errno(err);
 }
 
 // static
 Error Error::fromSystemError(unsigned int src)
 {
     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_syserror()));
 }
 
 // static
 Error Error::fromErrno(int err, unsigned int src)
 {
     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_errno(err)));
 }
 
 // static
 Error Error::fromCode(unsigned int err, unsigned int src)
 {
     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), static_cast<gpgme_err_code_t>(err)));
 }
 
 std::ostream &operator<<(std::ostream &os, const Error &err)
 {
     return os << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
 }
 
 Context::Context(gpgme_ctx_t ctx) : d(new Private(ctx))
 {
 }
 
 Context::~Context()
 {
     delete d;
 }
 
 Context *Context::createForProtocol(Protocol proto)
 {
-    gpgme_ctx_t ctx = 0;
+    gpgme_ctx_t ctx = nullptr;
     if (gpgme_new(&ctx) != 0) {
-        return 0;
+        return nullptr;
     }
 
     switch (proto) {
     case OpenPGP:
         if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP) != 0) {
             gpgme_release(ctx);
-            return 0;
+            return nullptr;
         }
         break;
     case CMS:
         if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS) != 0) {
             gpgme_release(ctx);
-            return 0;
+            return nullptr;
         }
         break;
     default:
-        return 0;
+        return nullptr;
     }
 
     return new Context(ctx);
 }
 
 std::unique_ptr<Context> Context::create(Protocol proto)
 {
   return std::unique_ptr <Context> (createForProtocol(proto));
 }
 
 std::unique_ptr<Context> Context::createForEngine(Engine eng, Error *error)
 {
-    gpgme_ctx_t ctx = 0;
+    gpgme_ctx_t ctx = nullptr;
     if (const gpgme_error_t err = gpgme_new(&ctx)) {
         if (error) {
             *error = Error(err);
         }
         return std::unique_ptr<Context>();
     }
 
     switch (eng) {
     case AssuanEngine:
         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_ASSUAN)) {
             gpgme_release(ctx);
             if (error) {
                 *error = Error(err);
             }
             return std::unique_ptr<Context>();
         }
         break;
     case G13Engine:
         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_G13)) {
             gpgme_release(ctx);
             if (error) {
                 *error = Error(err);
             }
             return std::unique_ptr<Context>();
         }
         break;
     case SpawnEngine:
         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_SPAWN)) {
             gpgme_release(ctx);
             if (error) {
                 *error = Error(err);
             }
             return std::unique_ptr<Context>();
         }
         break;
     default:
         if (error) {
             *error = Error::fromCode(GPG_ERR_INV_ARG);
         }
         return std::unique_ptr<Context>();
     }
 
     if (error) {
         *error = Error();
     }
 
     return std::unique_ptr<Context>(new Context(ctx));
 }
 
 void Context::setDecryptionFlags(DecryptionFlags flags)
 {
     d->decryptFlags = flags;
 }
 
 //
 //
 // Context::Private
 //
 //
 
 Context::Private::Private(gpgme_ctx_t c)
     : ctx(c),
-      iocbs(0),
+      iocbs(nullptr),
       lastop(None),
       lasterr(GPG_ERR_NO_ERROR),
       lastAssuanInquireData(Data::null),
       lastAssuanTransaction(),
       lastEditInteractor(),
       lastCardEditInteractor(),
       decryptFlags(DecryptNone)
 {
 
 }
 
 Context::Private::~Private()
 {
     if (ctx) {
         gpgme_release(ctx);
     }
-    ctx = 0;
+    ctx = nullptr;
     delete iocbs;
 }
 
 //
 //
 // Context attributes:
 //
 //
 
 Protocol Context::protocol() const
 {
     gpgme_protocol_t p = gpgme_get_protocol(d->ctx);
     switch (p) {
     case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
     case GPGME_PROTOCOL_CMS:     return CMS;
     default:                     return UnknownProtocol;
     }
 }
 
 void Context::setArmor(bool useArmor)
 {
     gpgme_set_armor(d->ctx, int(useArmor));
 }
 bool Context::armor() const
 {
     return gpgme_get_armor(d->ctx);
 }
 
 void Context::setTextMode(bool useTextMode)
 {
     gpgme_set_textmode(d->ctx, int(useTextMode));
 }
 bool Context::textMode() const
 {
     return gpgme_get_textmode(d->ctx);
 }
 
 void Context::setOffline(bool useOfflineMode)
 {
     gpgme_set_offline(d->ctx, int(useOfflineMode));
 }
 bool Context::offline() const
 {
     return gpgme_get_offline(d->ctx);
 }
 
 void Context::setIncludeCertificates(int which)
 {
     if (which == DefaultCertificates) {
         which = GPGME_INCLUDE_CERTS_DEFAULT;
     }
     gpgme_set_include_certs(d->ctx, which);
 }
 
 int Context::includeCertificates() const
 {
     return gpgme_get_include_certs(d->ctx);
 }
 
 void Context::setKeyListMode(unsigned int mode)
 {
     gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(0, mode));
 }
 
 void Context::addKeyListMode(unsigned int mode)
 {
     const unsigned int cur = gpgme_get_keylist_mode(d->ctx);
     gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(cur, mode));
 }
 
 unsigned int Context::keyListMode() const
 {
     return convert_from_gpgme_keylist_mode_t(gpgme_get_keylist_mode(d->ctx));
 }
 
 void Context::setProgressProvider(ProgressProvider *provider)
 {
-    gpgme_set_progress_cb(d->ctx, provider ? &progress_callback : 0, provider);
+    gpgme_set_progress_cb(d->ctx, provider ? &progress_callback : nullptr, provider);
 }
 ProgressProvider *Context::progressProvider() const
 {
-    void *pp = 0;
+    void *pp = nullptr;
     gpgme_progress_cb_t pcb = &progress_callback;
     gpgme_get_progress_cb(d->ctx, &pcb, &pp);
     return static_cast<ProgressProvider *>(pp);
 }
 
 void Context::setPassphraseProvider(PassphraseProvider *provider)
 {
-    gpgme_set_passphrase_cb(d->ctx, provider ? &passphrase_callback : 0, provider);
+    gpgme_set_passphrase_cb(d->ctx, provider ? &passphrase_callback : nullptr, provider);
 }
 
 PassphraseProvider *Context::passphraseProvider() const
 {
-    void *pp = 0;
+    void *pp = nullptr;
     gpgme_passphrase_cb_t pcb = &passphrase_callback;
     gpgme_get_passphrase_cb(d->ctx, &pcb, &pp);
     return static_cast<PassphraseProvider *>(pp);
 }
 
 void Context::setManagedByEventLoopInteractor(bool manage)
 {
     if (!EventLoopInteractor::instance()) {
 #ifndef NDEBUG
         cerr << "Context::setManagedByEventLoopInteractor(): "
              "You must create an instance of EventLoopInteractor "
              "before using anything that needs one." << endl;
 #endif
         return;
     }
     if (manage) {
         EventLoopInteractor::instance()->manage(this);
     } else {
         EventLoopInteractor::instance()->unmanage(this);
     }
 }
 bool Context::managedByEventLoopInteractor() const
 {
-    return d->iocbs != 0;
+    return d->iocbs != nullptr;
 }
 
 void Context::installIOCallbacks(gpgme_io_cbs *iocbs)
 {
     if (!iocbs) {
         uninstallIOCallbacks();
         return;
     }
     gpgme_set_io_cbs(d->ctx, iocbs);
     delete d->iocbs; d->iocbs = iocbs;
 }
 
 void Context::uninstallIOCallbacks()
 {
-    static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 };
+    static gpgme_io_cbs noiocbs = { nullptr, nullptr, nullptr, nullptr, nullptr };
     // io.add == 0 means disable io callbacks:
     gpgme_set_io_cbs(d->ctx, &noiocbs);
-    delete d->iocbs; d->iocbs = 0;
+    delete d->iocbs; d->iocbs = nullptr;
 }
 
 Error Context::setLocale(int cat, const char *val)
 {
     return Error(d->lasterr = gpgme_set_locale(d->ctx, cat, val));
 }
 
 EngineInfo Context::engineInfo() const
 {
     return EngineInfo(gpgme_ctx_get_engine_info(d->ctx));
 }
 
 Error Context::setEngineFileName(const char *filename)
 {
     const char *const home_dir = engineInfo().homeDirectory();
     return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
 }
 
 Error Context::setEngineHomeDirectory(const char *home_dir)
 {
     const char *const filename = engineInfo().fileName();
     return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
 }
 
 Error Context::setSender (const char *sender)
 {
     return Error(gpgme_set_sender(d->ctx, sender));
 }
 
 const char *Context::getSender ()
 {
     return gpgme_get_sender(d->ctx);
 }
 
 //
 //
 // Key Management
 //
 //
 
 Error Context::startKeyListing(const char *pattern, bool secretOnly)
 {
     d->lastop = Private::KeyList;
     return Error(d->lasterr = gpgme_op_keylist_start(d->ctx, pattern, int(secretOnly)));
 }
 
 Error Context::startKeyListing(const char *patterns[], bool secretOnly)
 {
     d->lastop = Private::KeyList;
 #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     if (!patterns || !patterns[0] || !patterns[1]) {
         // max. one pattern -> use the non-ext version
-        return startKeyListing(patterns ? patterns[0] : 0, secretOnly);
+        return startKeyListing(patterns ? patterns[0] : nullptr, secretOnly);
     }
 #endif
     return Error(d->lasterr = gpgme_op_keylist_ext_start(d->ctx, patterns, int(secretOnly), 0));
 }
 
 Key Context::nextKey(GpgME::Error &e)
 {
     d->lastop = Private::KeyList;
     gpgme_key_t key = nullptr;
     e = Error(d->lasterr = gpgme_op_keylist_next(d->ctx, &key));
     return Key(key, false);
 }
 
 KeyListResult Context::endKeyListing()
 {
     d->lasterr = gpgme_op_keylist_end(d->ctx);
     return keyListResult();
 }
 
 KeyListResult Context::keyListResult() const
 {
     return KeyListResult(d->ctx, Error(d->lasterr));
 }
 
 Key Context::key(const char *fingerprint, GpgME::Error &e , bool secret /*, bool forceUpdate*/)
 {
     d->lastop = Private::KeyList;
     gpgme_key_t key = nullptr;
     e = Error(d->lasterr = gpgme_get_key(d->ctx, fingerprint, &key, int(secret)/*, int( forceUpdate )*/));
     return Key(key, false);
 }
 
 KeyGenerationResult Context::generateKey(const char *parameters, Data &pubKey)
 {
     d->lastop = Private::KeyGen;
     Data::Private *const dp = pubKey.impl();
-    d->lasterr = gpgme_op_genkey(d->ctx, parameters, dp ? dp->data : 0, 0);
+    d->lasterr = gpgme_op_genkey(d->ctx, parameters, dp ? dp->data : nullptr, nullptr);
     return KeyGenerationResult(d->ctx, Error(d->lasterr));
 }
 
 Error Context::startKeyGeneration(const char *parameters, Data &pubKey)
 {
     d->lastop = Private::KeyGen;
     Data::Private *const dp = pubKey.impl();
-    return Error(d->lasterr = gpgme_op_genkey_start(d->ctx, parameters, dp ? dp->data : 0, 0));
+    return Error(d->lasterr = gpgme_op_genkey_start(d->ctx, parameters, dp ? dp->data : nullptr, nullptr));
 }
 
 KeyGenerationResult Context::keyGenerationResult() const
 {
     if (d->lastop & Private::KeyGen) {
         return KeyGenerationResult(d->ctx, Error(d->lasterr));
     } else {
         return KeyGenerationResult();
     }
 }
 
 Error Context::exportPublicKeys(const char *pattern, Data &keyData)
 {
     d->lastop = Private::Export;
     Data::Private *const dp = keyData.impl();
-    return Error(d->lasterr = gpgme_op_export(d->ctx, pattern, 0, dp ? dp->data : 0));
+    return Error(d->lasterr = gpgme_op_export(d->ctx, pattern, 0, dp ? dp->data : nullptr));
 }
 
 Error Context::exportPublicKeys(const char *patterns[], Data &keyData)
 {
     d->lastop = Private::Export;
 #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     if (!patterns || !patterns[0] || !patterns[1]) {
         // max. one pattern -> use the non-ext version
-        return exportPublicKeys(patterns ? patterns[0] : 0, keyData);
+        return exportPublicKeys(patterns ? patterns[0] : nullptr, keyData);
     }
 #endif
     Data::Private *const dp = keyData.impl();
-    return Error(d->lasterr = gpgme_op_export_ext(d->ctx, patterns, 0, dp ? dp->data : 0));
+    return Error(d->lasterr = gpgme_op_export_ext(d->ctx, patterns, 0, dp ? dp->data : nullptr));
 }
 
 Error Context::startPublicKeyExport(const char *pattern, Data &keyData)
 {
     d->lastop = Private::Export;
     Data::Private *const dp = keyData.impl();
-    return Error(d->lasterr = gpgme_op_export_start(d->ctx, pattern, 0, dp ? dp->data : 0));
+    return Error(d->lasterr = gpgme_op_export_start(d->ctx, pattern, 0, dp ? dp->data : nullptr));
 }
 
 Error Context::startPublicKeyExport(const char *patterns[], Data &keyData)
 {
     d->lastop = Private::Export;
 #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     if (!patterns || !patterns[0] || !patterns[1]) {
         // max. one pattern -> use the non-ext version
-        return startPublicKeyExport(patterns ? patterns[0] : 0, keyData);
+        return startPublicKeyExport(patterns ? patterns[0] : nullptr, keyData);
     }
 #endif
     Data::Private *const dp = keyData.impl();
-    return Error(d->lasterr = gpgme_op_export_ext_start(d->ctx, patterns, 0, dp ? dp->data : 0));
+    return Error(d->lasterr = gpgme_op_export_ext_start(d->ctx, patterns, 0, dp ? dp->data : nullptr));
 }
 
 ImportResult Context::importKeys(const Data &data)
 {
     d->lastop = Private::Import;
     const Data::Private *const dp = data.impl();
-    d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
+    d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : nullptr);
     return ImportResult(d->ctx, Error(d->lasterr));
 }
 
 ImportResult Context::importKeys(const std::vector<Key> &kk)
 {
     d->lastop = Private::Import;
     d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED);
 
     bool shouldHaveResult = false;
     gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
     gpgme_key_t *keys_it = &keys[0];
     for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
         if (it->impl()) {
             *keys_it++ = it->impl();
         }
     }
-    *keys_it++ = 0;
+    *keys_it++ = nullptr;
     d->lasterr = gpgme_op_import_keys(d->ctx, keys);
     shouldHaveResult = true;
     if ((gpgme_err_code(d->lasterr) == GPG_ERR_NOT_IMPLEMENTED ||
             gpgme_err_code(d->lasterr) == GPG_ERR_NOT_SUPPORTED) &&
             protocol() == CMS) {
         // ok, try the workaround (export+import):
         std::vector<const char *> fprs;
         for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
             if (const char *fpr = it->primaryFingerprint()) {
                 if (*fpr) {
                     fprs.push_back(fpr);
                 }
             } else if (const char *keyid = it->keyID()) {
                 if (*keyid) {
                     fprs.push_back(keyid);
                 }
             }
         }
-        fprs.push_back(0);
+        fprs.push_back(nullptr);
         Data data;
         Data::Private *const dp = data.impl();
         const gpgme_keylist_mode_t oldMode = gpgme_get_keylist_mode(d->ctx);
         gpgme_set_keylist_mode(d->ctx, GPGME_KEYLIST_MODE_EXTERN);
-        d->lasterr = gpgme_op_export_ext(d->ctx, &fprs[0], 0, dp ? dp->data : 0);
+        d->lasterr = gpgme_op_export_ext(d->ctx, &fprs[0], 0, dp ? dp->data : nullptr);
         gpgme_set_keylist_mode(d->ctx, oldMode);
         if (!d->lasterr) {
             data.seek(0, SEEK_SET);
-            d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
+            d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : nullptr);
             shouldHaveResult = true;
         }
     }
     delete[] keys;
     if (shouldHaveResult) {
         return ImportResult(d->ctx, Error(d->lasterr));
     } else {
         return ImportResult(Error(d->lasterr));
     }
 }
 
 Error Context::startKeyImport(const Data &data)
 {
     d->lastop = Private::Import;
     const Data::Private *const dp = data.impl();
-    return Error(d->lasterr = gpgme_op_import_start(d->ctx, dp ? dp->data : 0));
+    return Error(d->lasterr = gpgme_op_import_start(d->ctx, dp ? dp->data : nullptr));
 }
 
 Error Context::startKeyImport(const std::vector<Key> &kk)
 {
     d->lastop = Private::Import;
     gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
     gpgme_key_t *keys_it = &keys[0];
     for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
         if (it->impl()) {
             *keys_it++ = it->impl();
         }
     }
-    *keys_it++ = 0;
+    *keys_it++ = nullptr;
     Error err = Error(d->lasterr = gpgme_op_import_keys_start(d->ctx, keys));
     delete[] keys;
     return err;
 }
 
 ImportResult Context::importResult() const
 {
     if (d->lastop & Private::Import) {
         return ImportResult(d->ctx, Error(d->lasterr));
     } else {
         return ImportResult();
     }
 }
 
 Error Context::deleteKey(const Key &key, bool allowSecretKeyDeletion)
 {
     d->lastop = Private::Delete;
     return Error(d->lasterr = gpgme_op_delete(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
 }
 
 Error Context::startKeyDeletion(const Key &key, bool allowSecretKeyDeletion)
 {
     d->lastop = Private::Delete;
     return Error(d->lasterr = gpgme_op_delete_start(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
 }
 
 Error Context::passwd(const Key &key)
 {
     d->lastop = Private::Passwd;
     return Error(d->lasterr = gpgme_op_passwd(d->ctx, key.impl(), 0U));
 }
 
 Error Context::startPasswd(const Key &key)
 {
     d->lastop = Private::Passwd;
     return Error(d->lasterr = gpgme_op_passwd_start(d->ctx, key.impl(), 0U));
 }
 
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 Error Context::edit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
 {
     d->lastop = Private::Edit;
     d->lastEditInteractor = std::move(func);
     Data::Private *const dp = data.impl();
     return Error(d->lasterr = gpgme_op_edit(d->ctx, key.impl(),
-                                            d->lastEditInteractor.get() ? edit_interactor_callback : 0,
-                                            d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
-                                            dp ? dp->data : 0));
+                                            d->lastEditInteractor.get() ? edit_interactor_callback : nullptr,
+                                            d->lastEditInteractor.get() ? d->lastEditInteractor->d : nullptr,
+                                            dp ? dp->data : nullptr));
 }
 
 
 Error Context::startEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
 {
     d->lastop = Private::Edit;
     d->lastEditInteractor = std::move(func);
     Data::Private *const dp = data.impl();
     return Error(d->lasterr = gpgme_op_edit_start(d->ctx, key.impl(),
-                              d->lastEditInteractor.get() ? edit_interactor_callback : 0,
-                              d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
-                              dp ? dp->data : 0));
+                              d->lastEditInteractor.get() ? edit_interactor_callback : nullptr,
+                              d->lastEditInteractor.get() ? d->lastEditInteractor->d : nullptr,
+                              dp ? dp->data : nullptr));
 }
 
 
 EditInteractor *Context::lastEditInteractor() const
 {
     return d->lastEditInteractor.get();
 }
 
 std::unique_ptr<EditInteractor> Context::takeLastEditInteractor()
 {
     return std::move(d->lastEditInteractor);
 }
 
 
 Error Context::cardEdit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
 {
     d->lastop = Private::CardEdit;
     d->lastCardEditInteractor = std::move(func);
     Data::Private *const dp = data.impl();
     return Error(d->lasterr = gpgme_op_card_edit(d->ctx, key.impl(),
-                              d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
-                              d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
-                              dp ? dp->data : 0));
+                              d->lastCardEditInteractor.get() ? edit_interactor_callback : nullptr,
+                              d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : nullptr,
+                              dp ? dp->data : nullptr));
 }
 
 Error Context::startCardEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
 {
     d->lastop = Private::CardEdit;
     d->lastCardEditInteractor = std::move(func);
     Data::Private *const dp = data.impl();
     return Error(d->lasterr = gpgme_op_card_edit_start(d->ctx, key.impl(),
-                              d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
-                              d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
-                              dp ? dp->data : 0));
+                              d->lastCardEditInteractor.get() ? edit_interactor_callback : nullptr,
+                              d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : nullptr,
+                              dp ? dp->data : nullptr));
 }
 
 #pragma GCC diagnostic pop
 
 EditInteractor *Context::lastCardEditInteractor() const
 {
     return d->lastCardEditInteractor.get();
 }
 
 std::unique_ptr<EditInteractor> Context::takeLastCardEditInteractor()
 {
     return std::move(d->lastCardEditInteractor);
 }
 
 Error Context::startTrustItemListing(const char *pattern, int maxLevel)
 {
     d->lastop = Private::TrustList;
     return Error(d->lasterr = gpgme_op_trustlist_start(d->ctx, pattern, maxLevel));
 }
 
 TrustItem Context::nextTrustItem(Error &e)
 {
-    gpgme_trust_item_t ti = 0;
+    gpgme_trust_item_t ti = nullptr;
     e = Error(d->lasterr = gpgme_op_trustlist_next(d->ctx, &ti));
     return TrustItem(ti);
 }
 
 Error Context::endTrustItemListing()
 {
     return Error(d->lasterr = gpgme_op_trustlist_end(d->ctx));
 }
 
 static gpgme_error_t assuan_transaction_data_callback(void *opaque, const void *data, size_t datalen)
 {
     assert(opaque);
     AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque);
     return t->data(static_cast<const char *>(data), datalen).encodedError();
 }
 
 static gpgme_error_t assuan_transaction_inquire_callback(void *opaque, const char *name, const char *args, gpgme_data_t *r_data)
 {
     assert(opaque);
     Context::Private *p = static_cast<Context::Private *>(opaque);
     AssuanTransaction *t = p->lastAssuanTransaction.get();
     assert(t);
     Error err;
     if (name) {
         p->lastAssuanInquireData = t->inquire(name, args, err);
     } else {
         p->lastAssuanInquireData = Data::null;
     }
     if (!p->lastAssuanInquireData.isNull()) {
         *r_data = p->lastAssuanInquireData.impl()->data;
     }
     return err.encodedError();
 }
 
 static gpgme_error_t assuan_transaction_status_callback(void *opaque, const char *status, const char *args)
 {
     assert(opaque);
     AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque);
     std::string a = args;
     percent_unescape(a, true);   // ### why doesn't gpgme do this??
     return t->status(status, a.c_str()).encodedError();
 }
 
 Error Context::assuanTransact(const char *command)
 {
     return assuanTransact(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
 }
 
 Error Context::assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction)
 {
     gpgme_error_t err, operr;
 
     d->lastop = Private::AssuanTransact;
     d->lastAssuanTransaction = std::move(transaction);
     if (!d->lastAssuanTransaction.get()) {
         return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
     }
     err = gpgme_op_assuan_transact_ext
       (d->ctx,
        command,
        assuan_transaction_data_callback,
        d->lastAssuanTransaction.get(),
        assuan_transaction_inquire_callback,
        d,
        assuan_transaction_status_callback,
        d->lastAssuanTransaction.get(),
        &operr);
 
     if (!err)
       err = operr;
     d->lasterr = err;
 
     return Error(d->lasterr);
 }
 
 Error Context::startAssuanTransaction(const char *command)
 {
     return startAssuanTransaction(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
 }
 
 Error Context::startAssuanTransaction(const char *command, std::unique_ptr<AssuanTransaction> transaction)
 {
     gpgme_error_t err;
 
     d->lastop = Private::AssuanTransact;
     d->lastAssuanTransaction = std::move(transaction);
     if (!d->lastAssuanTransaction.get()) {
         return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
     }
     err = gpgme_op_assuan_transact_start
       (d->ctx,
        command,
        assuan_transaction_data_callback,
        d->lastAssuanTransaction.get(),
        assuan_transaction_inquire_callback,
        d,
        assuan_transaction_status_callback,
        d->lastAssuanTransaction.get());
 
     d->lasterr = err;
 
     return Error(d->lasterr);
 }
 
 AssuanTransaction *Context::lastAssuanTransaction() const
 {
     return d->lastAssuanTransaction.get();
 }
 
 std::unique_ptr<AssuanTransaction> Context::takeLastAssuanTransaction()
 {
     return std::move(d->lastAssuanTransaction);
 }
 
 DecryptionResult Context::decrypt(const Data &cipherText, Data &plainText, const DecryptionFlags flags)
 {
     d->lastop = Private::Decrypt;
     const Data::Private *const cdp = cipherText.impl();
     Data::Private *const pdp = plainText.impl();
-    d->lasterr = gpgme_op_decrypt_ext(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags), cdp ? cdp->data : 0, pdp ? pdp->data : 0);
+    d->lasterr = gpgme_op_decrypt_ext(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags), cdp ? cdp->data : nullptr, pdp ? pdp->data : nullptr);
     return DecryptionResult(d->ctx, Error(d->lasterr));
 }
 
 DecryptionResult Context::decrypt(const Data &cipherText, Data &plainText)
 {
     return decrypt(cipherText, plainText, DecryptNone);
 }
 
 Error Context::startDecryption(const Data &cipherText, Data &plainText, const DecryptionFlags flags)
 {
     d->lastop = Private::Decrypt;
     const Data::Private *const cdp = cipherText.impl();
     Data::Private *const pdp = plainText.impl();
     return Error(d->lasterr = gpgme_op_decrypt_ext_start(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags),
-                 cdp ? cdp->data : 0, pdp ? pdp->data : 0));
+                 cdp ? cdp->data : nullptr, pdp ? pdp->data : nullptr));
 }
 
 Error Context::startDecryption(const Data &cipherText, Data &plainText)
 {
     return startDecryption(cipherText, plainText, DecryptNone);
 }
 
 DecryptionResult Context::decryptionResult() const
 {
     if (d->lastop & Private::Decrypt) {
         return DecryptionResult(d->ctx, Error(d->lasterr));
     } else {
         return DecryptionResult();
     }
 }
 
 VerificationResult Context::verifyDetachedSignature(const Data &signature, const Data &signedText)
 {
     d->lastop = Private::Verify;
     const Data::Private *const sdp = signature.impl();
     const Data::Private *const tdp = signedText.impl();
-    d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0);
+    d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : nullptr, tdp ? tdp->data : nullptr, nullptr);
     return VerificationResult(d->ctx, Error(d->lasterr));
 }
 
 VerificationResult Context::verifyOpaqueSignature(const Data &signedData, Data &plainText)
 {
     d->lastop = Private::Verify;
     const Data::Private *const sdp = signedData.impl();
     Data::Private *const pdp = plainText.impl();
-    d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0);
+    d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : nullptr, nullptr, pdp ? pdp->data : nullptr);
     return VerificationResult(d->ctx, Error(d->lasterr));
 }
 
 Error Context::startDetachedSignatureVerification(const Data &signature, const Data &signedText)
 {
     d->lastop = Private::Verify;
     const Data::Private *const sdp = signature.impl();
     const Data::Private *const tdp = signedText.impl();
-    return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0));
+    return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : nullptr, tdp ? tdp->data : nullptr, nullptr));
 }
 
 Error Context::startOpaqueSignatureVerification(const Data &signedData, Data &plainText)
 {
     d->lastop = Private::Verify;
     const Data::Private *const sdp = signedData.impl();
     Data::Private *const pdp = plainText.impl();
-    return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0));
+    return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : nullptr, nullptr, pdp ? pdp->data : nullptr));
 }
 
 VerificationResult Context::verificationResult() const
 {
     if (d->lastop & Private::Verify) {
         return VerificationResult(d->ctx, Error(d->lasterr));
     } else {
         return VerificationResult();
     }
 }
 
 std::pair<DecryptionResult, VerificationResult> Context::decryptAndVerify(const Data &cipherText, Data &plainText, DecryptionFlags flags)
 {
     d->lastop = Private::DecryptAndVerify;
     const Data::Private *const cdp = cipherText.impl();
     Data::Private *const pdp = plainText.impl();
     d->lasterr = gpgme_op_decrypt_ext(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags | DecryptVerify),
-                                      cdp ? cdp->data : 0, pdp ? pdp->data : 0);
+                                      cdp ? cdp->data : nullptr, pdp ? pdp->data : nullptr);
     return std::make_pair(DecryptionResult(d->ctx, Error(d->lasterr)),
                           VerificationResult(d->ctx, Error(d->lasterr)));
 }
 
 std::pair<DecryptionResult, VerificationResult> Context::decryptAndVerify(const Data &cipherText, Data &plainText)
 {
     return decryptAndVerify(cipherText, plainText, DecryptNone);
 }
 
 Error Context::startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText, DecryptionFlags flags)
 {
     d->lastop = Private::DecryptAndVerify;
     const Data::Private *const cdp = cipherText.impl();
     Data::Private *const pdp = plainText.impl();
-    return Error(d->lasterr = gpgme_op_decrypt_ext_start(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags | DecryptVerify), cdp ? cdp->data : 0, pdp ? pdp->data : 0));
+    return Error(d->lasterr = gpgme_op_decrypt_ext_start(d->ctx, static_cast<gpgme_decrypt_flags_t> (d->decryptFlags | flags | DecryptVerify), cdp ? cdp->data : nullptr, pdp ? pdp->data : nullptr));
 }
 
 Error Context::startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText)
 {
     return startCombinedDecryptionAndVerification(cipherText, plainText, DecryptNone);
 }
 
 unsigned int to_auditlog_flags(unsigned int flags)
 {
     unsigned int result = 0;
     if (flags & Context::HtmlAuditLog) {
         result |= GPGME_AUDITLOG_HTML;
     }
     if (flags & Context::AuditLogWithHelp) {
         result |= GPGME_AUDITLOG_WITH_HELP;
     }
     if (flags & Context::DiagnosticAuditLog) {
         result |= GPGME_AUDITLOG_DIAG;
     }
     return result;
 }
 
 Error Context::startGetAuditLog(Data &output, unsigned int flags)
 {
     d->lastop = Private::GetAuditLog;
     Data::Private *const odp = output.impl();
-    return Error(d->lasterr = gpgme_op_getauditlog_start(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
+    return Error(d->lasterr = gpgme_op_getauditlog_start(d->ctx, odp ? odp->data : nullptr, to_auditlog_flags(flags)));
 }
 
 Error Context::getAuditLog(Data &output, unsigned int flags)
 {
     d->lastop = Private::GetAuditLog;
     Data::Private *const odp = output.impl();
-    return Error(d->lasterr = gpgme_op_getauditlog(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
+    return Error(d->lasterr = gpgme_op_getauditlog(d->ctx, odp ? odp->data : nullptr, to_auditlog_flags(flags)));
 }
 
 void Context::clearSigningKeys()
 {
     gpgme_signers_clear(d->ctx);
 }
 
 Error Context::addSigningKey(const Key &key)
 {
     return Error(d->lasterr = gpgme_signers_add(d->ctx, key.impl()));
 }
 
 Key Context::signingKey(unsigned int idx) const
 {
     gpgme_key_t key = gpgme_signers_enum(d->ctx, idx);
     return Key(key, false);
 }
 
 std::vector<Key> Context::signingKeys() const
 {
     std::vector<Key> result;
     gpgme_key_t key = nullptr;
     for (unsigned int i = 0 ; (key = gpgme_signers_enum(d->ctx, i)) ; ++i) {
         result.push_back(Key(key, false));
     }
     return result;
 }
 
 void Context::clearSignatureNotations()
 {
     gpgme_sig_notation_clear(d->ctx);
 }
 
 GpgME::Error Context::addSignatureNotation(const char *name, const char *value, unsigned int flags)
 {
     return Error(gpgme_sig_notation_add(d->ctx, name, value, add_to_gpgme_sig_notation_flags_t(0, flags)));
 }
 
 GpgME::Error Context::addSignaturePolicyURL(const char *url, bool critical)
 {
-    return Error(gpgme_sig_notation_add(d->ctx, 0, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0));
+    return Error(gpgme_sig_notation_add(d->ctx, nullptr, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0));
 }
 
 const char *Context::signaturePolicyURL() const
 {
     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
         if (!n->name) {
             return n->value;
         }
     }
     return nullptr;
 }
 
 Notation Context::signatureNotation(unsigned int idx) const
 {
     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
         if (n->name) {
             if (idx-- == 0) {
                 return Notation(n);
             }
         }
     }
     return Notation();
 }
 
 std::vector<Notation> Context::signatureNotations() const
 {
     std::vector<Notation> result;
     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
         if (n->name) {
             result.push_back(Notation(n));
         }
     }
     return result;
 }
 
 static gpgme_sig_mode_t sigmode2sigmode(SignatureMode mode)
 {
     switch (mode) {
     default:
     case NormalSignatureMode: return GPGME_SIG_MODE_NORMAL;
     case Detached:            return GPGME_SIG_MODE_DETACH;
     case Clearsigned:         return GPGME_SIG_MODE_CLEAR;
     }
 }
 
 SigningResult Context::sign(const Data &plainText, Data &signature, SignatureMode mode)
 {
     d->lastop = Private::Sign;
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const sdp = signature.impl();
-    d->lasterr = gpgme_op_sign(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode));
+    d->lasterr = gpgme_op_sign(d->ctx, pdp ? pdp->data : nullptr, sdp ? sdp->data : nullptr, sigmode2sigmode(mode));
     return SigningResult(d->ctx, Error(d->lasterr));
 }
 
 Error Context::startSigning(const Data &plainText, Data &signature, SignatureMode mode)
 {
     d->lastop = Private::Sign;
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const sdp = signature.impl();
-    return Error(d->lasterr = gpgme_op_sign_start(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode)));
+    return Error(d->lasterr = gpgme_op_sign_start(d->ctx, pdp ? pdp->data : nullptr, sdp ? sdp->data : nullptr, sigmode2sigmode(mode)));
 }
 
 SigningResult Context::signingResult() const
 {
     if (d->lastop & Private::Sign) {
         return SigningResult(d->ctx, Error(d->lasterr));
     } else {
         return SigningResult();
     }
 }
 
 static gpgme_encrypt_flags_t encryptflags2encryptflags(Context::EncryptionFlags flags)
 {
     unsigned int result = 0;
     if (flags & Context::AlwaysTrust) {
         result |= GPGME_ENCRYPT_ALWAYS_TRUST;
     }
     if (flags & Context::NoEncryptTo) {
         result |= GPGME_ENCRYPT_NO_ENCRYPT_TO;
     }
     if (flags & Context::Prepare) {
         result |= GPGME_ENCRYPT_PREPARE;
     }
     if (flags & Context::ExpectSign) {
         result |= GPGME_ENCRYPT_EXPECT_SIGN;
     }
     if (flags & Context::NoCompress) {
         result |= GPGME_ENCRYPT_NO_COMPRESS;
     }
     if (flags & Context::Symmetric) {
         result |= GPGME_ENCRYPT_SYMMETRIC;
     }
     return static_cast<gpgme_encrypt_flags_t>(result);
 }
 
 gpgme_key_t *Context::getKeysFromRecipients(const std::vector<Key> &recipients)
 {
     if (recipients.empty()) {
         return nullptr;
     }
     gpgme_key_t *ret = new gpgme_key_t[ recipients.size() + 1 ];
     gpgme_key_t *keys_it = ret;
     for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
         if (it->impl()) {
             *keys_it++ = it->impl();
         }
     }
-    *keys_it++ = 0;
+    *keys_it++ = nullptr;
     return ret;
 }
 
 EncryptionResult Context::encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
 {
     d->lastop = Private::Encrypt;
     if (flags & NoEncryptTo) {
         return EncryptionResult(Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED)));
     }
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const cdp = cipherText.impl();
     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
     d->lasterr = gpgme_op_encrypt(d->ctx, keys, encryptflags2encryptflags(flags),
-                                  pdp ? pdp->data : 0, cdp ? cdp->data : 0);
+                                  pdp ? pdp->data : nullptr, cdp ? cdp->data : nullptr);
     if (keys) {
         delete[] keys;
     }
     return EncryptionResult(d->ctx, Error(d->lasterr));
 }
 
 Error Context::encryptSymmetrically(const Data &plainText, Data &cipherText)
 {
     d->lastop = Private::Encrypt;
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const cdp = cipherText.impl();
-    return Error(d->lasterr = gpgme_op_encrypt(d->ctx, 0, (gpgme_encrypt_flags_t)0,
-                              pdp ? pdp->data : 0, cdp ? cdp->data : 0));
+    return Error(d->lasterr = gpgme_op_encrypt(d->ctx, nullptr, (gpgme_encrypt_flags_t)0,
+                              pdp ? pdp->data : nullptr, cdp ? cdp->data : nullptr));
 }
 
 Error Context::startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
 {
     d->lastop = Private::Encrypt;
     if (flags & NoEncryptTo) {
         return Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED));
     }
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const cdp = cipherText.impl();
     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
     d->lasterr = gpgme_op_encrypt_start(d->ctx, keys, encryptflags2encryptflags(flags),
-                                        pdp ? pdp->data : 0, cdp ? cdp->data : 0);
+                                        pdp ? pdp->data : nullptr, cdp ? cdp->data : nullptr);
     if (keys) {
         delete[] keys;
     }
     return Error(d->lasterr);
 }
 
 EncryptionResult Context::encryptionResult() const
 {
     if (d->lastop & Private::Encrypt) {
         return EncryptionResult(d->ctx, Error(d->lasterr));
     } else {
         return EncryptionResult();
     }
 }
 
 std::pair<SigningResult, EncryptionResult> Context::signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
 {
     d->lastop = Private::SignAndEncrypt;
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const cdp = cipherText.impl();
     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
     d->lasterr = gpgme_op_encrypt_sign(d->ctx, keys, encryptflags2encryptflags(flags),
-                                       pdp ? pdp->data : 0, cdp ? cdp->data : 0);
+                                       pdp ? pdp->data : nullptr, cdp ? cdp->data : nullptr);
     if (keys) {
         delete[] keys;
     }
     return std::make_pair(SigningResult(d->ctx, Error(d->lasterr)),
                           EncryptionResult(d->ctx, Error(d->lasterr)));
 }
 
 Error Context::startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
 {
     d->lastop = Private::SignAndEncrypt;
     const Data::Private *const pdp = plainText.impl();
     Data::Private *const cdp = cipherText.impl();
     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
     d->lasterr = gpgme_op_encrypt_sign_start(d->ctx, keys, encryptflags2encryptflags(flags),
-                 pdp ? pdp->data : 0, cdp ? cdp->data : 0);
+                 pdp ? pdp->data : nullptr, cdp ? cdp->data : nullptr);
     if (keys) {
         delete[] keys;
     }
     return Error(d->lasterr);
 }
 
 Error Context::createVFS(const char *containerFile, const std::vector< Key > &recipients)
 {
     d->lastop = Private::CreateVFS;
     gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ];
     gpgme_key_t *keys_it = keys;
     for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
         if (it->impl()) {
             *keys_it++ = it->impl();
         }
     }
-    *keys_it++ = 0;
+    *keys_it++ = nullptr;
 
     gpgme_error_t op_err;
     d->lasterr = gpgme_op_vfs_create(d->ctx, keys, containerFile, 0, &op_err);
     delete[] keys;
     Error error(d->lasterr);
     if (error) {
         return error;
     }
     return Error(d->lasterr = op_err);
 }
 
 VfsMountResult Context::mountVFS(const char *containerFile, const char *mountDir)
 {
     d->lastop = Private::MountVFS;
     gpgme_error_t op_err;
     d->lasterr = gpgme_op_vfs_mount(d->ctx, containerFile, mountDir, 0, &op_err);
     return VfsMountResult(d->ctx, Error(d->lasterr), Error(op_err));
 }
 
 Error Context::cancelPendingOperation()
 {
     return Error(gpgme_cancel_async(d->ctx));
 }
 
 bool Context::poll()
 {
     gpgme_error_t e = GPG_ERR_NO_ERROR;
     const bool finished = gpgme_wait(d->ctx, &e, 0);
     if (finished) {
         d->lasterr = e;
     }
     return finished;
 }
 
 Error Context::wait()
 {
     gpgme_error_t e = GPG_ERR_NO_ERROR;
     gpgme_wait(d->ctx, &e, 1);
     return Error(d->lasterr = e);
 }
 
 Error Context::lastError() const
 {
     return Error(d->lasterr);
 }
 
 Context::PinentryMode Context::pinentryMode() const
 {
     switch (gpgme_get_pinentry_mode (d->ctx)) {
         case GPGME_PINENTRY_MODE_ASK:
             return PinentryAsk;
         case GPGME_PINENTRY_MODE_CANCEL:
             return PinentryCancel;
         case GPGME_PINENTRY_MODE_ERROR:
             return PinentryError;
         case GPGME_PINENTRY_MODE_LOOPBACK:
             return PinentryLoopback;
         case GPGME_PINENTRY_MODE_DEFAULT:
         default:
             return PinentryDefault;
     }
 }
 
 Error Context::setPinentryMode(PinentryMode which)
 {
     gpgme_pinentry_mode_t mode;
     switch (which) {
         case PinentryAsk:
             mode = GPGME_PINENTRY_MODE_ASK;
             break;
         case PinentryCancel:
             mode = GPGME_PINENTRY_MODE_CANCEL;
             break;
         case PinentryError:
             mode = GPGME_PINENTRY_MODE_ERROR;
             break;
         case PinentryLoopback:
             mode = GPGME_PINENTRY_MODE_LOOPBACK;
             break;
         case PinentryDefault:
         default:
             mode = GPGME_PINENTRY_MODE_DEFAULT;
     }
     return Error(d->lasterr = gpgme_set_pinentry_mode(d->ctx, mode));
 }
 
 static gpgme_tofu_policy_t to_tofu_policy_t(unsigned int policy)
 {
     switch (policy) {
         case TofuInfo::PolicyNone:
             return GPGME_TOFU_POLICY_NONE;
         case TofuInfo::PolicyAuto:
             return GPGME_TOFU_POLICY_AUTO;
         case TofuInfo::PolicyGood:
             return GPGME_TOFU_POLICY_GOOD;
         case TofuInfo::PolicyBad:
             return GPGME_TOFU_POLICY_BAD;
         case TofuInfo::PolicyAsk:
             return GPGME_TOFU_POLICY_ASK;
         case TofuInfo::PolicyUnknown:
         default:
             return GPGME_TOFU_POLICY_UNKNOWN;
     }
 }
 
 Error Context::setTofuPolicy(const Key &k, unsigned int policy)
 {
     return Error(d->lasterr = gpgme_op_tofu_policy(d->ctx,
                  k.impl(), to_tofu_policy_t(policy)));
 }
 
 Error Context::setTofuPolicyStart(const Key &k, unsigned int policy)
 {
     return Error(d->lasterr = gpgme_op_tofu_policy_start(d->ctx,
                  k.impl(), to_tofu_policy_t(policy)));
 }
 
 Error Context::startCreateKey (const char *userid,
                                const char *algo,
                                unsigned long reserved,
                                unsigned long expires,
                                const Key &certkey,
                                unsigned int flags)
 {
     return Error(d->lasterr = gpgme_op_createkey_start(d->ctx,
                  userid,
                  algo,
                  reserved,
                  expires,
                  certkey.impl(),
                  flags));
 }
 
 Error Context::createKey (const char *userid,
                           const char *algo,
                           unsigned long reserved,
                           unsigned long expires,
                           const Key &certkey,
                           unsigned int flags)
 {
     return Error(d->lasterr = gpgme_op_createkey(d->ctx,
                  userid,
                  algo,
                  reserved,
                  expires,
                  certkey.impl(),
                  flags));
 }
 
 KeyGenerationResult Context::createKeyEx (const char *userid,
                                           const char *algo,
                                           unsigned long reserved,
                                           unsigned long expires,
                                           const Key &certkey,
                                           unsigned int flags)
 {
     d->lasterr = gpgme_op_createkey(d->ctx,
                  userid,
                  algo,
                  reserved,
                  expires,
                  certkey.impl(),
                  flags);
     return KeyGenerationResult(d->ctx, Error(d->lasterr));
 }
 
 Error Context::addUid(const Key &k, const char *userid)
 {
     return Error(d->lasterr = gpgme_op_adduid(d->ctx,
                  k.impl(), userid, 0));
 }
 
 Error Context::startAddUid(const Key &k, const char *userid)
 {
     return Error(d->lasterr = gpgme_op_adduid_start(d->ctx,
                  k.impl(), userid, 0));
 }
 
 Error Context::revUid(const Key &k, const char *userid)
 {
     return Error(d->lasterr = gpgme_op_revuid(d->ctx,
                  k.impl(), userid, 0));
 }
 
 Error Context::startRevUid(const Key &k, const char *userid)
 {
     return Error(d->lasterr = gpgme_op_revuid_start(d->ctx,
                  k.impl(), userid, 0));
 }
 
 Error Context::createSubkey(const Key &k, const char *algo,
                             unsigned long reserved,
                             unsigned long expires,
                             unsigned int flags)
 {
     return Error(d->lasterr = gpgme_op_createsubkey(d->ctx,
                  k.impl(), algo, reserved, expires, flags));
 }
 
 Error Context::startCreateSubkey(const Key &k, const char *algo,
                                  unsigned long reserved,
                                  unsigned long expires,
                                  unsigned int flags)
 {
     return Error(d->lasterr = gpgme_op_createsubkey_start(d->ctx,
                  k.impl(), algo, reserved, expires, flags));
 }
 
 Error Context::setFlag(const char *name, const char *value)
 {
   return Error(d->lasterr = gpgme_set_ctx_flag(d->ctx, name, value));
 }
 
 const char *Context::getFlag(const char *name) const
 {
   return gpgme_get_ctx_flag(d->ctx, name);
 }
 
 // Engine Spawn stuff
 Error Context::spawn(const char *file, const char *argv[],
                      Data &input, Data &output, Data &err,
                      SpawnFlags flags)
 {
     return Error(d->lasterr = gpgme_op_spawn (d->ctx, file, argv,
         input.impl() ? input.impl()->data : nullptr,
         output.impl() ? output.impl()->data : nullptr,
         err.impl() ? err.impl()->data : nullptr,
         static_cast<int>(flags)));
 }
 
 Error Context::spawnAsync(const char *file, const char *argv[],
                           Data &input, Data &output, Data &err,
                           SpawnFlags flags)
 {
     return Error(d->lasterr = gpgme_op_spawn_start (d->ctx, file, argv,
         input.impl() ? input.impl()->data : nullptr,
         output.impl() ? output.impl()->data : nullptr,
         err.impl() ? err.impl()->data : nullptr,
         static_cast<int>(flags)));
 }
 
 std::ostream &operator<<(std::ostream &os, Protocol proto)
 {
     os << "GpgME::Protocol(";
     switch (proto) {
     case OpenPGP:
         os << "OpenPGP";
         break;
     case CMS:
         os << "CMS";
         break;
     default:
     case UnknownProtocol:
         os << "UnknownProtocol";
         break;
     }
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, Engine eng)
 {
     os << "GpgME::Engine(";
     switch (eng) {
     case GpgEngine:
         os << "GpgEngine";
         break;
     case GpgSMEngine:
         os << "GpgSMEngine";
         break;
     case GpgConfEngine:
         os << "GpgConfEngine";
         break;
     case AssuanEngine:
         os << "AssuanEngine";
         break;
     case SpawnEngine:
         os << "SpawnEngine";
         break;
     default:
     case UnknownEngine:
         os << "UnknownEngine";
         break;
     }
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl)
 {
     os << "GpgME::Context::CertificateInclusion(" << static_cast<int>(incl);
     switch (incl) {
     case Context::DefaultCertificates:
         os << "(DefaultCertificates)";
         break;
     case Context::AllCertificatesExceptRoot:
         os << "(AllCertificatesExceptRoot)";
         break;
     case Context::AllCertificates:
         os << "(AllCertificates)";
         break;
     case Context::NoCertificates:
         os << "(NoCertificates)";
         break;
     case Context::OnlySenderCertificate:
         os << "(OnlySenderCertificate)";
         break;
     }
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, KeyListMode mode)
 {
     os << "GpgME::KeyListMode(";
 #define CHECK( x ) if ( !(mode & (x)) ) {} else do { os << #x " "; } while (0)
     CHECK(Local);
     CHECK(Extern);
     CHECK(Signatures);
     CHECK(Validate);
     CHECK(Ephemeral);
     CHECK(WithTofu);
 #undef CHECK
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, SignatureMode mode)
 {
     os << "GpgME::SignatureMode(";
     switch (mode) {
 #define CHECK( x ) case x: os << #x; break
         CHECK(NormalSignatureMode);
         CHECK(Detached);
         CHECK(Clearsigned);
 #undef CHECK
     default:
         os << "???" "(" << static_cast<int>(mode) << ')';
         break;
     }
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags)
 {
     os << "GpgME::Context::EncryptionFlags(";
 #define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
     CHECK(AlwaysTrust);
     CHECK(NoEncryptTo);
     CHECK(Prepare);
     CHECK(ExpectSign);
     CHECK(NoCompress);
     CHECK(Symmetric);
 #undef CHECK
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags)
 {
     os << "GpgME::Context::AuditLogFlags(";
 #define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
     CHECK(HtmlAuditLog);
     CHECK(AuditLogWithHelp);
 #undef CHECK
     return os << ')';
 }
 
 } // namespace GpgME
 
 GpgME::Error GpgME::setDefaultLocale(int cat, const char *val)
 {
-    return Error(gpgme_set_locale(0, cat, val));
+    return Error(gpgme_set_locale(nullptr, cat, val));
 }
 
 GpgME::EngineInfo GpgME::engineInfo(GpgME::Protocol proto)
 {
-    gpgme_engine_info_t ei = 0;
+    gpgme_engine_info_t ei = nullptr;
     if (gpgme_get_engine_info(&ei)) {
         return EngineInfo();
     }
 
     const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
 
     for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
         if (i->protocol == p) {
             return EngineInfo(i);
         }
     }
 
     return EngineInfo();
 }
 
 const char *GpgME::dirInfo(const char *what)
 {
     return gpgme_get_dirinfo(what);
 }
 
 GpgME::Error GpgME::checkEngine(GpgME::Protocol proto)
 {
     const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
 
     return Error(gpgme_engine_check_version(p));
 }
 
 static const gpgme_protocol_t UNKNOWN_PROTOCOL = static_cast<gpgme_protocol_t>(255);
 
 static gpgme_protocol_t engine2protocol(const GpgME::Engine engine)
 {
     switch (engine) {
     case GpgME::GpgEngine:   return GPGME_PROTOCOL_OpenPGP;
     case GpgME::GpgSMEngine: return GPGME_PROTOCOL_CMS;
     case GpgME::GpgConfEngine:
         return GPGME_PROTOCOL_GPGCONF;
     case GpgME::AssuanEngine:
         return GPGME_PROTOCOL_ASSUAN;
     case GpgME::G13Engine:
         return GPGME_PROTOCOL_G13;
     case GpgME::SpawnEngine:
         return GPGME_PROTOCOL_SPAWN;
     case GpgME::UnknownEngine:
         ;
     }
     return UNKNOWN_PROTOCOL;
 }
 
 GpgME::EngineInfo GpgME::engineInfo(GpgME::Engine engine)
 {
-    gpgme_engine_info_t ei = 0;
+    gpgme_engine_info_t ei = nullptr;
     if (gpgme_get_engine_info(&ei)) {
         return EngineInfo();
     }
 
     const gpgme_protocol_t p = engine2protocol(engine);
 
     for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
         if (i->protocol == p) {
             return EngineInfo(i);
         }
     }
 
     return EngineInfo();
 }
 
 GpgME::Error GpgME::checkEngine(GpgME::Engine engine)
 {
     const gpgme_protocol_t p = engine2protocol(engine);
 
     return Error(gpgme_engine_check_version(p));
 }
 
 static const unsigned long supported_features = 0
         | GpgME::ValidatingKeylistModeFeature
         | GpgME::CancelOperationFeature
         | GpgME::WrongKeyUsageFeature
         | GpgME::DefaultCertificateInclusionFeature
         | GpgME::GetSetEngineInfoFeature
         | GpgME::ClearAddGetSignatureNotationsFeature
         | GpgME::SetDataFileNameFeeature
         | GpgME::SignatureNotationsKeylistModeFeature
         | GpgME::KeySignatureNotationsFeature
         | GpgME::KeyIsQualifiedFeature
         | GpgME::SignatureNotationsCriticalFlagFeature
         | GpgME::SignatureNotationsFlagsFeature
         | GpgME::SignatureNotationsHumanReadableFlagFeature
         | GpgME::SubkeyIsQualifiedFeature
         | GpgME::EngineInfoHomeDirFeature
         | GpgME::DecryptionResultFileNameFeature
         | GpgME::DecryptionResultRecipientsFeature
         | GpgME::VerificationResultFileNameFeature
         | GpgME::SignaturePkaFieldsFeature
         | GpgME::SignatureAlgorithmFieldsFeature
         | GpgME::FdPointerFeature
         | GpgME::AuditLogFeature
         | GpgME::GpgConfEngineFeature
         | GpgME::CancelOperationAsyncFeature
         | GpgME::NoEncryptToEncryptionFlagFeature
         | GpgME::CardKeyFeature
         | GpgME::AssuanEngineFeature
         | GpgME::EphemeralKeylistModeFeature
         | GpgME::ImportFromKeyserverFeature
         | GpgME::G13VFSFeature
         | GpgME::PasswdFeature
         ;
 
 static const unsigned long supported_features2 = 0
         | GpgME::BinaryAndFineGrainedIdentify
         ;
 
 bool GpgME::hasFeature(unsigned long features)
 {
     return features == (features & supported_features);
 }
 
 bool GpgME::hasFeature(unsigned long features, unsigned long features2)
 {
     return features  == (features  & supported_features)
            && features2 == (features2 & supported_features2)
            ;
 }
diff --git a/lang/cpp/src/context.h b/lang/cpp/src/context.h
index d3700e03..b6b902a9 100644
--- a/lang/cpp/src/context.h
+++ b/lang/cpp/src/context.h
@@ -1,491 +1,491 @@
 /*
   context.h - wraps a gpgme key context
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_CONTEXT_H__
 #define __GPGMEPP_CONTEXT_H__
 
 #include "global.h"
 
 #include "error.h"
 #include "verificationresult.h" // for Signature::Notation
 
 #include <memory>
 #include <vector>
 #include <utility>
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class Key;
 class Data;
 class TrustItem;
 class ProgressProvider;
 class PassphraseProvider;
 class EventLoopInteractor;
 class EditInteractor;
 class AssuanTransaction;
 
 class KeyListResult;
 class KeyGenerationResult;
 class ImportResult;
 class DecryptionResult;
 class VerificationResult;
 class SigningResult;
 class EncryptionResult;
 class VfsMountResult;
 
 class EngineInfo;
 
 class GPGMEPP_EXPORT Context
 {
     explicit Context(gpgme_ctx_t);
 public:
     //using GpgME::Protocol;
 
     //
     // Creation and destruction:
     //
 
     static Context *createForProtocol(Protocol proto);
     /** Same as above but returning a unique ptr. */
     static std::unique_ptr<Context> create(Protocol proto);
-    static std::unique_ptr<Context> createForEngine(Engine engine, Error *err = 0);
+    static std::unique_ptr<Context> createForEngine(Engine engine, Error *err = nullptr);
     virtual ~Context();
 
     //
     // Context Attributes
     //
 
     Protocol protocol() const;
 
     void setArmor(bool useArmor);
     bool armor() const;
 
     void setTextMode(bool useTextMode);
     bool textMode() const;
 
     void setOffline(bool useOfflineMode);
     bool offline() const;
 
     const char *getFlag(const char *name) const;
     Error setFlag(const char *name, const char *value);
 
     enum CertificateInclusion {
         DefaultCertificates = -256,
         AllCertificatesExceptRoot = -2,
         AllCertificates = -1,
         NoCertificates = 0,
         OnlySenderCertificate = 1
     };
     void setIncludeCertificates(int which);
     int includeCertificates() const;
 
     //using GpgME::KeyListMode;
     void setKeyListMode(unsigned int keyListMode);
     void addKeyListMode(unsigned int keyListMode);
     unsigned int keyListMode() const;
 
     /** Set the passphrase provider
      *
      * To avoid problems where a class using a context registers
      * itself as the provider the Context does not take ownership
      * of the provider and the caller must ensure that the provider
      * is deleted if it is no longer needed.
      */
     void setPassphraseProvider(PassphraseProvider *provider);
     PassphraseProvider *passphraseProvider() const;
 
     /** Set the progress provider
      *
      * To avoid problems where a class using a context registers
      * itself as the provider the Context does not take ownership
      * of the provider and the caller must ensure that the provider
      * is deleted if it is no longer needed.
      */
     void setProgressProvider(ProgressProvider *provider);
     ProgressProvider *progressProvider() const;
 
     void setManagedByEventLoopInteractor(bool managed);
     bool managedByEventLoopInteractor() const;
 
     GpgME::Error setLocale(int category, const char *value);
 
     EngineInfo engineInfo() const;
     GpgME::Error setEngineFileName(const char *filename);
     GpgME::Error setEngineHomeDirectory(const char *filename);
 
     enum PinentryMode{
         PinentryDefault = 0,
         PinentryAsk = 1,
         PinentryCancel = 2,
         PinentryError = 3,
         PinentryLoopback = 4
     };
     GpgME::Error setPinentryMode(PinentryMode which);
     PinentryMode pinentryMode() const;
 
 private:
     friend class ::GpgME::EventLoopInteractor;
     void installIOCallbacks(gpgme_io_cbs *iocbs);
     void uninstallIOCallbacks();
 
 public:
     //
     //
     // Key Management
     //
     //
 
     //
     // Key Listing
     //
 
-    GpgME::Error startKeyListing(const char *pattern = 0, bool secretOnly = false);
+    GpgME::Error startKeyListing(const char *pattern = nullptr, bool secretOnly = false);
     GpgME::Error startKeyListing(const char *patterns[], bool secretOnly = false);
 
     Key nextKey(GpgME::Error &e);
 
     KeyListResult endKeyListing();
     KeyListResult keyListResult() const;
 
     Key key(const char *fingerprint, GpgME::Error &e, bool secret = false);
 
     //
     // Key Generation
     //
 
     KeyGenerationResult generateKey(const char *parameters, Data &pubKey);
     GpgME::Error startKeyGeneration(const char *parameters, Data &pubkey);
     KeyGenerationResult keyGenerationResult() const;
 
     //
     // Key Export
     //
 
     GpgME::Error exportPublicKeys(const char *pattern, Data &keyData);
     GpgME::Error exportPublicKeys(const char *pattern[], Data &keyData);
     GpgME::Error startPublicKeyExport(const char *pattern, Data &keyData);
     GpgME::Error startPublicKeyExport(const char *pattern[], Data &keyData);
 
     //
     // Key Import
     //
 
     ImportResult importKeys(const Data &data);
     ImportResult importKeys(const std::vector<Key> &keys);
     GpgME::Error startKeyImport(const Data &data);
     GpgME::Error startKeyImport(const std::vector<Key> &keys);
     ImportResult importResult() const;
 
     //
     // Key Deletion
     //
 
     GpgME::Error deleteKey(const Key &key, bool allowSecretKeyDeletion = false);
     GpgME::Error startKeyDeletion(const Key &key, bool allowSecretKeyDeletion = false);
 
     //
     // Passphrase changing
     //
 
     GpgME::Error passwd(const Key &key);
     GpgME::Error startPasswd(const Key &key);
 
     //
     // Key Editing
     //
 
     GpgME::Error edit(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
     GpgME::Error startEditing(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
 
 
     //
     // Modern Interface actions. Require 2.1.x
     //
     Error startCreateKey (const char *userid,
                           const char *algo,
                           unsigned long reserved,
                           unsigned long expires,
                           const Key &certkey,
                           unsigned int flags);
     Error createKey (const char *userid,
                      const char *algo,
                      unsigned long reserved,
                      unsigned long expires,
                      const Key &certkey,
                      unsigned int flags);
 
     // Same as create key but returning a result
     GpgME::KeyGenerationResult createKeyEx (const char *userid,
                                             const char *algo,
                                             unsigned long reserved,
                                             unsigned long expires,
                                             const Key &certkey,
                                             unsigned int flags);
 
     Error addUid(const Key &key, const char *userid);
     Error startAddUid(const Key &key, const char *userid);
 
     Error revUid(const Key &key, const char *userid);
     Error startRevUid(const Key &key, const char *userid);
 
     Error createSubkey(const Key &key, const char *algo,
                        unsigned long reserved = 0,
                        unsigned long expires = 0,
                        unsigned int flags = 0);
     Error startCreateSubkey(const Key &key, const char *algo,
                             unsigned long reserved = 0,
                             unsigned long expires = 0,
                             unsigned int flags = 0);
 
     // using TofuInfo::Policy
     Error setTofuPolicy(const Key &k, unsigned int policy);
     Error setTofuPolicyStart(const Key &k, unsigned int policy);
 
     EditInteractor *lastEditInteractor() const;
     std::unique_ptr<EditInteractor> takeLastEditInteractor();
 
     //
     // SmartCard Editing
     //
 
     GpgME::Error cardEdit(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
     GpgME::Error startCardEditing(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
 
     EditInteractor *lastCardEditInteractor() const;
     std::unique_ptr<EditInteractor> takeLastCardEditInteractor();
 
     //
     // Trust Item Management
     //
 
     GpgME::Error startTrustItemListing(const char *pattern, int maxLevel);
     TrustItem nextTrustItem(GpgME::Error &e);
     GpgME::Error endTrustItemListing();
 
     //
     // Assuan Transactions
     //
 
     GpgME::Error assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction);
     GpgME::Error assuanTransact(const char *command);
     GpgME::Error startAssuanTransaction(const char *command, std::unique_ptr<AssuanTransaction> transaction);
     GpgME::Error startAssuanTransaction(const char *command);
 
     AssuanTransaction *lastAssuanTransaction() const;
     std::unique_ptr<AssuanTransaction> takeLastAssuanTransaction();
 
     //
     //
     // Crypto Operations
     //
 
     enum DecryptionFlags {
         // Keep in line with core's flags
         DecryptNone = 0,
         DecryptVerify = 1,
         DecryptUnwrap = 128,
         DecryptMaxValue = 0x80000000
     };
 
     //
     // Decryption
     //
 
     // Alternative way to set decryption flags as they were added only in
     // 1.9.0 and so other API can still be used but with 1.9.0 additionally
     // flags can be set.
     void setDecryptionFlags (const DecryptionFlags flags);
 
     DecryptionResult decrypt(const Data &cipherText, Data &plainText);
     GpgME::Error startDecryption(const Data &cipherText, Data &plainText);
     DecryptionResult decrypt(const Data &cipherText, Data &plainText, const DecryptionFlags flags);
     GpgME::Error startDecryption(const Data &cipherText, Data &plainText, const DecryptionFlags flags);
     DecryptionResult decryptionResult() const;
 
     //
     // Signature Verification
     //
 
     VerificationResult verifyDetachedSignature(const Data &signature, const Data &signedText);
     VerificationResult verifyOpaqueSignature(const Data &signedData, Data &plainText);
     GpgME::Error startDetachedSignatureVerification(const Data &signature, const Data &signedText);
     GpgME::Error startOpaqueSignatureVerification(const Data &signedData, Data &plainText);
     VerificationResult verificationResult() const;
 
     //
     // Combined Decryption and Signature Verification
     //
 
     std::pair<DecryptionResult, VerificationResult> decryptAndVerify(const Data &cipherText, Data &plainText);
     std::pair<DecryptionResult, VerificationResult> decryptAndVerify(const Data &cipherText, Data &plainText, const DecryptionFlags flags);
     GpgME::Error startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText);
     GpgME::Error startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText, const DecryptionFlags flags);
     // use verificationResult() and decryptionResult() to retrieve the result objects...
 
     //
     // Signing
     //
 
     void clearSigningKeys();
     GpgME::Error addSigningKey(const Key &signer);
     Key signingKey(unsigned int index) const;
     std::vector<Key> signingKeys() const;
 
     void clearSignatureNotations();
     GpgME::Error addSignatureNotation(const char *name, const char *value, unsigned int flags = 0);
     GpgME::Error addSignaturePolicyURL(const char *url, bool critical = false);
     const char *signaturePolicyURL() const;
     Notation signatureNotation(unsigned int index) const;
     std::vector<Notation> signatureNotations() const;
 
     //using GpgME::SignatureMode;
     SigningResult sign(const Data &plainText, Data &signature, SignatureMode mode);
     GpgME::Error startSigning(const Data &plainText, Data &signature, SignatureMode mode);
     SigningResult signingResult() const;
 
     // wrapper for gpgme_set_sender
     const char *getSender();
     GpgME::Error setSender(const char *sender);
 
     //
     // Encryption
     //
 
     enum EncryptionFlags {
         None = 0,
         AlwaysTrust = 1,
         NoEncryptTo = 2,
         Prepare = 4,
         ExpectSign = 8,
         NoCompress = 16,
         Symmetric = 32,
         ThrowKeyIds = 64,
         EncryptWrap = 128
     };
     EncryptionResult encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
     GpgME::Error encryptSymmetrically(const Data &plainText, Data &cipherText);
     GpgME::Error startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
     EncryptionResult encryptionResult() const;
 
     //
     // Combined Signing and Encryption
     //
 
     std::pair<SigningResult, EncryptionResult> signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
     GpgME::Error startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
     // use encryptionResult() and signingResult() to retrieve the result objects...
 
     //
     //
     // Audit Log
     //
     //
     enum AuditLogFlags {
         DefaultAuditLog = 0,
         HtmlAuditLog = 1,
         DiagnosticAuditLog = 2,
         AuditLogWithHelp = 128
     };
     GpgME::Error startGetAuditLog(Data &output, unsigned int flags = 0);
     GpgME::Error getAuditLog(Data &output, unsigned int flags = 0);
 
     //
     //
     // G13 crypto container operations
     //
     //
     GpgME::Error createVFS(const char *containerFile, const std::vector<Key> &recipients);
     VfsMountResult mountVFS(const char *containerFile, const char *mountDir);
 
     // Spawn Engine
     enum SpawnFlags {
         SpawnNone = 0,
         SpawnDetached = 1,
         SpawnAllowSetFg = 2,
         SpawnShowWindow = 4
     };
     /** Spwan the process \a file with arguments \a argv.
      *
      *  If a data parameter is null the /dev/null will be
      *  used. (Or other platform stuff).
      *
      * @param file The executable to start.
      * @param argv list of arguments file should be argv[0].
      * @param input The data to be sent through stdin.
      * @param output The data to be receive the stdout.
      * @param err The data to receive stderr.
      * @param flags Additional flags.
      *
      * @returns An error or empty error.
      */
     GpgME::Error spawn(const char *file, const char *argv[],
                        Data &input, Data &output, Data &err,
                        SpawnFlags flags);
     /** Async variant of spawn. Immediately returns after starting the
      * process. */
     GpgME::Error spawnAsync(const char *file, const char *argv[],
                             Data &input, Data &output,
                             Data &err, SpawnFlags flags);
     //
     //
     // Run Control
     //
     //
 
     bool poll();
     GpgME::Error wait();
     GpgME::Error lastError() const;
     GpgME::Error cancelPendingOperation();
 
     class Private;
     const Private *impl() const
     {
         return d;
     }
     Private *impl()
     {
         return d;
     }
 
 private:
     // Helper functions that need to be context because they rely
     // on the "Friendlyness" of context to access the gpgme types.
     gpgme_key_t *getKeysFromRecipients(const std::vector<Key> &recipients);
 
 private:
     Private *const d;
 
 private: // disable...
     Context(const Context &);
     const Context &operator=(const Context &);
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags);
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_CONTEXT_H__
diff --git a/lang/cpp/src/context_p.h b/lang/cpp/src/context_p.h
index 6b0a0805..491e7f77 100644
--- a/lang/cpp/src/context_p.h
+++ b/lang/cpp/src/context_p.h
@@ -1,87 +1,87 @@
 /*
   context_p.h - wraps a gpgme context (private part)
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_CONTEXT_P_H__
 #define __GPGMEPP_CONTEXT_P_H__
 
 #include <context.h>
 #include <data.h>
 
 #include <gpgme.h>
 
 namespace GpgME
 {
 
 class Context::Private
 {
 public:
     enum Operation {
         None = 0,
 
         Encrypt   = 0x001,
         Decrypt   = 0x002,
         Sign      = 0x004,
         Verify    = 0x008,
         DecryptAndVerify = Decrypt | Verify,
         SignAndEncrypt   = Sign | Encrypt,
 
         Import    = 0x010,
         Export    = 0x020, // no gpgme_export_result_t, but nevertheless...
         Delete    = 0x040, // no gpgme_delete_result_t, but nevertheless...
 
         KeyGen    = 0x080,
         KeyList   = 0x100,
         TrustList = 0x200, // no gpgme_trustlist_result_t, but nevertheless...
 
         Edit      = 0x400, // no gpgme_edit_result_t, but nevertheless...
         CardEdit  = 0x800, // no gpgme_card_edit_result_t, but nevertheless...
 
         GetAuditLog = 0x1000, // no gpgme_getauditlog_result_t, but nevertheless...
 
         AssuanTransact = 0x2000,
         Passwd    = 0x4000, // no gpgme_passwd_result_t, but nevertheless...
 
         CreateVFS = 0x4000,
         MountVFS = 0x8000,
 
         EndMarker
     };
 
-    Private(gpgme_ctx_t c = 0);
+    Private(gpgme_ctx_t c = nullptr);
     ~Private();
 
     gpgme_ctx_t ctx;
     gpgme_io_cbs *iocbs;
     Operation lastop;
     gpgme_error_t lasterr;
     Data lastAssuanInquireData;
     std::unique_ptr<AssuanTransaction> lastAssuanTransaction;
     std::unique_ptr<EditInteractor> lastEditInteractor, lastCardEditInteractor;
     DecryptionFlags decryptFlags;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_CONTEXT_P_H__
diff --git a/lang/cpp/src/context_vanilla.cpp b/lang/cpp/src/context_vanilla.cpp
index 60ddea20..1d7d14d5 100644
--- a/lang/cpp/src/context_vanilla.cpp
+++ b/lang/cpp/src/context_vanilla.cpp
@@ -1,39 +1,39 @@
 /*
   context_vanilla.cpp - wraps a gpgme key context, gpgme (vanilla)-specific functions
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <global.h>
 
 GIOChannel *GpgME::getGIOChannel(int)
 {
-    return 0;
+    return nullptr;
 }
 
 QIODevice *GpgME::getQIODevice(int)
 {
-    return 0;
+    return nullptr;
 }
diff --git a/lang/cpp/src/data.cpp b/lang/cpp/src/data.cpp
index 2782aa79..547ec76e 100644
--- a/lang/cpp/src/data.cpp
+++ b/lang/cpp/src/data.cpp
@@ -1,275 +1,275 @@
 /*
   data.cpp - wraps a gpgme data object
   Copyright (C) 2003 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "data_p.h"
 #include "context_p.h"
 #include <error.h>
 #include <interfaces/dataprovider.h>
 
 #include <gpgme.h>
 
 #ifndef NDEBUG
 #include <iostream>
 #endif
 
 GpgME::Data::Private::~Private()
 {
     if (data) {
         gpgme_data_release(data);
     }
 }
 
 const GpgME::Data::Null GpgME::Data::null;
 
 GpgME::Data::Data()
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new(&data);
-    d.reset(new Private(e ? 0 : data));
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(const Null &)
-    : d(new Private(0))
+    : d(new Private(nullptr))
 {
 
 }
 
 GpgME::Data::Data(gpgme_data_t data)
     : d(new Private(data))
 {
 
 }
 
 GpgME::Data::Data(const char *buffer, size_t size, bool copy)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy));
     std::string sizestr = std::to_string(size);
     // Ignore errors as this is optional
     gpgme_data_set_flag(data, "size-hint", sizestr.c_str());
-    d.reset(new Private(e ? 0 : data));
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(const char *filename)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new(&data);
-    d.reset(new Private(e ? 0 : data));
+    d.reset(new Private(e ? nullptr : data));
     if (!e) {
         setFileName(filename);
     }
 }
 
 GpgME::Data::Data(const char *filename, off_t offset, size_t length)
 {
     gpgme_data_t data;
-    const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, 0, offset, length);
-    d.reset(new Private(e ? 0 : data));
+    const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, nullptr, offset, length);
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(FILE *fp)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp);
-    d.reset(new Private(e ? 0 : data));
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(FILE *fp, off_t offset, size_t length)
 {
     gpgme_data_t data;
-    const gpgme_error_t e = gpgme_data_new_from_filepart(&data, 0, fp, offset, length);
-    d.reset(new Private(e ? 0 : data));
+    const gpgme_error_t e = gpgme_data_new_from_filepart(&data, nullptr, fp, offset, length);
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(int fd)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd);
-    d.reset(new Private(e ? 0 : data));
+    d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(DataProvider *dp)
 {
     d.reset(new Private);
     if (!dp) {
         return;
     }
     if (!dp->isSupported(DataProvider::Read)) {
-        d->cbs.read = 0;
+        d->cbs.read = nullptr;
     }
     if (!dp->isSupported(DataProvider::Write)) {
-        d->cbs.write = 0;
+        d->cbs.write = nullptr;
     }
     if (!dp->isSupported(DataProvider::Seek)) {
-        d->cbs.seek = 0;
+        d->cbs.seek = nullptr;
     }
     if (!dp->isSupported(DataProvider::Release)) {
-        d->cbs.release = 0;
+        d->cbs.release = nullptr;
     }
     const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp);
     if (e) {
-        d->data = 0;
+        d->data = nullptr;
     }
     if (dp->isSupported(DataProvider::Seek)) {
         off_t size = seek(0, SEEK_END);
         seek(0, SEEK_SET);
         std::string sizestr = std::to_string(size);
         // Ignore errors as this is optional
         gpgme_data_set_flag(d->data, "size-hint", sizestr.c_str());
     }
 #ifndef NDEBUG
     //std::cerr << "GpgME::Data(): DataProvider supports: "
     //    << ( d->cbs.read ? "read" : "no read" ) << ", "
     //    << ( d->cbs.write ? "write" : "no write" ) << ", "
     //    << ( d->cbs.seek ? "seek" : "no seek" ) << ", "
     //    << ( d->cbs.release ? "release" : "no release" ) << std::endl;
 #endif
 }
 
 bool GpgME::Data::isNull() const
 {
     return !d || !d->data;
 }
 
 GpgME::Data::Encoding GpgME::Data::encoding() const
 {
     switch (gpgme_data_get_encoding(d->data)) {
     case GPGME_DATA_ENCODING_NONE:   return AutoEncoding;
     case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding;
     case GPGME_DATA_ENCODING_BASE64: return Base64Encoding;
     case GPGME_DATA_ENCODING_ARMOR:  return ArmorEncoding;
     case GPGME_DATA_ENCODING_MIME:   return MimeEncoding;
     case GPGME_DATA_ENCODING_URL:    return UrlEncoding;
     case GPGME_DATA_ENCODING_URLESC: return UrlEscEncoding;
     case GPGME_DATA_ENCODING_URL0:   return Url0Encoding;
     }
     return AutoEncoding;
 }
 
 GpgME::Error GpgME::Data::setEncoding(Encoding enc)
 {
     gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE;
     switch (enc) {
     case AutoEncoding:   ge = GPGME_DATA_ENCODING_NONE;   break;
     case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break;
     case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break;
     case ArmorEncoding:  ge = GPGME_DATA_ENCODING_ARMOR;  break;
     case MimeEncoding:   ge = GPGME_DATA_ENCODING_MIME;  break;
     case UrlEncoding:    ge = GPGME_DATA_ENCODING_URL; break;
     case UrlEscEncoding: ge = GPGME_DATA_ENCODING_URLESC; break;
     case Url0Encoding:   ge = GPGME_DATA_ENCODING_URL0; break;
     }
     return Error(gpgme_data_set_encoding(d->data, ge));
 }
 
 GpgME::Data::Type GpgME::Data::type() const
 {
     if (isNull()) {
         return Invalid;
     }
     switch (gpgme_data_identify(d->data, 0)) {
     case GPGME_DATA_TYPE_INVALID:       return Invalid;
     case GPGME_DATA_TYPE_UNKNOWN:       return Unknown;
     case GPGME_DATA_TYPE_PGP_SIGNED:    return PGPSigned;
     case GPGME_DATA_TYPE_PGP_OTHER:     return PGPOther;
     case GPGME_DATA_TYPE_PGP_KEY:       return PGPKey;
     case GPGME_DATA_TYPE_CMS_SIGNED:    return CMSSigned;
     case GPGME_DATA_TYPE_CMS_ENCRYPTED: return CMSEncrypted;
     case GPGME_DATA_TYPE_CMS_OTHER:     return CMSOther;
     case GPGME_DATA_TYPE_X509_CERT:     return X509Cert;
     case GPGME_DATA_TYPE_PKCS12:        return PKCS12;
     case GPGME_DATA_TYPE_PGP_ENCRYPTED: return PGPEncrypted;
     case GPGME_DATA_TYPE_PGP_SIGNATURE: return PGPSignature;
     }
     return Invalid;
 }
 
 char *GpgME::Data::fileName() const
 {
     return gpgme_data_get_file_name(d->data);
 }
 
 GpgME::Error GpgME::Data::setFileName(const char *name)
 {
     return Error(gpgme_data_set_file_name(d->data, name));
 }
 
 ssize_t GpgME::Data::read(void *buffer, size_t length)
 {
     return gpgme_data_read(d->data, buffer, length);
 }
 
 ssize_t GpgME::Data::write(const void *buffer, size_t length)
 {
     return gpgme_data_write(d->data, buffer, length);
 }
 
 off_t GpgME::Data::seek(off_t offset, int whence)
 {
     return gpgme_data_seek(d->data, offset, whence);
 }
 
 GpgME::Error GpgME::Data::rewind()
 {
     return Error(gpgme_data_rewind(d->data));
 }
 
 std::vector<GpgME::Key> GpgME::Data::toKeys(Protocol proto) const
 {
     std::vector<GpgME::Key> ret;
     if (isNull()) {
         return ret;
     }
     auto ctx = GpgME::Context::createForProtocol(proto);
     if (!ctx) {
         return ret;
     }
 
     if (gpgme_op_keylist_from_data_start (ctx->impl()->ctx, d->data, 0)) {
         return ret;
     }
 
     gpgme_key_t key;
     while (!gpgme_op_keylist_next (ctx->impl()->ctx, &key)) {
         ret.push_back(GpgME::Key(key, false));
     }
     delete ctx;
     return ret;
 }
 
 std::string GpgME::Data::toString()
 {
   std::string ret;
   char buf[4096];
   size_t nread;
   seek (0, SEEK_SET);
   while ((nread = read (buf, 4096)) > 0)
     {
       ret += std::string (buf, nread);
     }
   seek (0, SEEK_SET);
   return ret;
 }
diff --git a/lang/cpp/src/data_p.h b/lang/cpp/src/data_p.h
index 493b7542..b52940c6 100644
--- a/lang/cpp/src/data_p.h
+++ b/lang/cpp/src/data_p.h
@@ -1,42 +1,42 @@
 /*
   data_p.h - wraps a gpgme data object, private part -*- c++ -*-
   Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_DATA_P_H__
 #define __GPGMEPP_DATA_P_H__
 
 #include <data.h>
 #include "callbacks.h"
 
 class GpgME::Data::Private
 {
 public:
-    explicit Private(gpgme_data_t d = 0)
+    explicit Private(gpgme_data_t d = nullptr)
         : data(d), cbs(data_provider_callbacks) {}
     ~Private();
 
     gpgme_data_t data;
     gpgme_data_cbs cbs;
 };
 
 #endif // __GPGMEPP_DATA_P_H__
diff --git a/lang/cpp/src/decryptionresult.cpp b/lang/cpp/src/decryptionresult.cpp
index ea0a8a5c..f78cf1d3 100644
--- a/lang/cpp/src/decryptionresult.cpp
+++ b/lang/cpp/src/decryptionresult.cpp
@@ -1,276 +1,276 @@
 /*
   decryptionresult.cpp - wraps a gpgme keygen result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <decryptionresult.h>
 #include "result_p.h"
 #include "util.h"
 
 #include <gpgme.h>
 
 #include <algorithm>
 #include <iterator>
 #include <cstring>
 #include <cstdlib>
 #include <istream>
 
 #include <string.h>
 
 class GpgME::DecryptionResult::Private
 {
 public:
     explicit Private(const _gpgme_op_decrypt_result &r) : res(r)
     {
         if (res.unsupported_algorithm) {
             res.unsupported_algorithm = strdup(res.unsupported_algorithm);
         }
         if (res.file_name) {
             res.file_name = strdup(res.file_name);
         }
         if (res.symkey_algo) {
             res.symkey_algo = strdup(res.symkey_algo);
         }
         //FIXME: copying gpgme_recipient_t objects invalidates the keyid member,
         //thus we use _keyid for now (internal API)
         for (gpgme_recipient_t r = res.recipients ; r ; r = r->next) {
             recipients.push_back(*r);
         }
-        res.recipients = 0;
+        res.recipients = nullptr;
     }
     ~Private()
     {
         if (res.unsupported_algorithm) {
             std::free(res.unsupported_algorithm);
         }
-        res.unsupported_algorithm = 0;
+        res.unsupported_algorithm = nullptr;
         if (res.file_name) {
             std::free(res.file_name);
         }
-        res.file_name = 0;
+        res.file_name = nullptr;
         if (res.symkey_algo) {
             std::free(res.symkey_algo);
         }
-        res.symkey_algo = 0;
+        res.symkey_algo = nullptr;
     }
 
     _gpgme_op_decrypt_result res;
     std::vector<_gpgme_recipient> recipients;
 };
 
 GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::DecryptionResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_decrypt_result_t res = gpgme_op_decrypt_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(*res));
 }
 
 make_standard_stuff(DecryptionResult)
 
 const char *GpgME::DecryptionResult::unsupportedAlgorithm() const
 {
-    return d ? d->res.unsupported_algorithm : 0 ;
+    return d ? d->res.unsupported_algorithm : nullptr ;
 }
 
 bool GpgME::DecryptionResult::isWrongKeyUsage() const
 {
     return d && d->res.wrong_key_usage;
 }
 
 bool GpgME::DecryptionResult::isDeVs() const
 {
     return d && d->res.is_de_vs;
 }
 
 const char *GpgME::DecryptionResult::fileName() const
 {
-    return d ? d->res.file_name : 0 ;
+    return d ? d->res.file_name : nullptr ;
 }
 
 unsigned int GpgME::DecryptionResult::numRecipients() const
 {
     return d ? d->recipients.size() : 0 ;
 }
 
 GpgME::DecryptionResult::Recipient GpgME::DecryptionResult::recipient(unsigned int idx) const
 {
     if (d && idx < d->recipients.size()) {
         return Recipient(&d->recipients[idx]);
     }
     return Recipient();
 }
 
 namespace
 {
 struct make_recipient {
     GpgME::DecryptionResult::Recipient operator()(_gpgme_recipient &t)
     {
         return GpgME::DecryptionResult::Recipient(&t);
     }
 };
 }
 
 std::vector<GpgME::DecryptionResult::Recipient> GpgME::DecryptionResult::recipients() const
 {
     std::vector<Recipient> result;
     if (d) {
         result.reserve(d->recipients.size());
         std::transform(d->recipients.begin(), d->recipients.end(),
                        std::back_inserter(result),
                        make_recipient());
     }
     return result;
 }
 
 const char *GpgME::DecryptionResult::sessionKey() const
 {
   return d ? d->res.session_key : nullptr;
 }
 
 const char *GpgME::DecryptionResult::symkeyAlgo() const
 {
   return d ? d->res.symkey_algo : nullptr;
 }
 
 bool GpgME::DecryptionResult::isLegacyCipherNoMDC() const
 {
   return d && d->res.legacy_cipher_nomdc;
 }
 
 class GpgME::DecryptionResult::Recipient::Private : public _gpgme_recipient
 {
 public:
     Private(gpgme_recipient_t reci) : _gpgme_recipient(*reci) {}
 };
 
 GpgME::DecryptionResult::Recipient::Recipient()
     : d()
 {
 
 }
 
 GpgME::DecryptionResult::Recipient::Recipient(gpgme_recipient_t r)
     : d()
 {
     if (r) {
         d.reset(new Private(r));
     }
 }
 
 bool GpgME::DecryptionResult::Recipient::isNull() const
 {
     return !d;
 }
 
 const char *GpgME::DecryptionResult::Recipient::keyID() const
 {
     //_keyid is internal API, but the public keyid is invalid after copying (see above)
     if (d) {
         return d->_keyid;
     }
-    return 0;
+    return nullptr;
 }
 
 const char *GpgME::DecryptionResult::Recipient::shortKeyID() const
 {
     //_keyid is internal API, but the public keyid is invalid after copying (see above)
     if (d) {
         return d->_keyid + 8;
     }
-    return 0;
+    return nullptr;
 }
 
 unsigned int GpgME::DecryptionResult::Recipient::publicKeyAlgorithm() const
 {
     if (d) {
         return d->pubkey_algo;
     }
     return 0;
 }
 
 const char *GpgME::DecryptionResult::Recipient::publicKeyAlgorithmAsString() const
 {
     if (d) {
         return gpgme_pubkey_algo_name(d->pubkey_algo);
     }
-    return 0;
+    return nullptr;
 }
 
 GpgME::Error GpgME::DecryptionResult::Recipient::status() const
 {
     if (d) {
         return Error(d->status);
     }
     return Error();
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult &result)
 {
     os << "GpgME::DecryptionResult(";
     if (!result.isNull()) {
         os << "\n error:                " << result.error()
            << "\n fileName:             " << protect(result.fileName())
            << "\n unsupportedAlgorithm: " << protect(result.unsupportedAlgorithm())
            << "\n isWrongKeyUsage:      " << result.isWrongKeyUsage()
            << "\n isDeVs                " << result.isDeVs()
            << "\n legacyCipherNoMDC     " << result.isLegacyCipherNoMDC()
            << "\n symkeyAlgo:           " << protect(result.symkeyAlgo())
            << "\n recipients:\n";
         const std::vector<DecryptionResult::Recipient> recipients = result.recipients();
         std::copy(recipients.begin(), recipients.end(),
                   std::ostream_iterator<DecryptionResult::Recipient>(os, "\n"));
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult::Recipient &reci)
 {
     os << "GpgME::DecryptionResult::Recipient(";
     if (!reci.isNull()) {
         os << "\n keyID:              " << protect(reci.keyID())
            << "\n shortKeyID:         " << protect(reci.shortKeyID())
            << "\n publicKeyAlgorithm: " << protect(reci.publicKeyAlgorithmAsString())
            << "\n status:             " << reci.status();
     }
     return os << ')';
 }
diff --git a/lang/cpp/src/defaultassuantransaction.h b/lang/cpp/src/defaultassuantransaction.h
index f294ffe2..5462f5f2 100644
--- a/lang/cpp/src/defaultassuantransaction.h
+++ b/lang/cpp/src/defaultassuantransaction.h
@@ -1,67 +1,67 @@
 /*
   defaultassuantransaction.h - default Assuan Transaction that just stores data and status lines
   Copyright (C) 2009 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_DEFAULTASSUANTRANSACTION_H__
 #define __GPGMEPP_DEFAULTASSUANTRANSACTION_H__
 
 #include <interfaces/assuantransaction.h>
 
 #include <string>
 #include <vector>
 #include <utility>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT DefaultAssuanTransaction : public AssuanTransaction
 {
 public:
     explicit DefaultAssuanTransaction();
     ~DefaultAssuanTransaction();
 
     const std::vector< std::pair<std::string, std::string> > &statusLines() const
     {
         return m_status;
     }
     std::vector<std::string> statusLine(const char *tag) const;
     std::string firstStatusLine(const char *tag) const;
 
     const std::string &data() const
     {
         return m_data;
     }
 
 private:
-    /* reimp */ Error data(const char *data, size_t datalen);
-    /* reimp */ Data inquire(const char *name, const char *args, Error &err);
-    /* reimp */ Error status(const char *status, const char *args);
+    Error data(const char *data, size_t datalen) override;
+    Data inquire(const char *name, const char *args, Error &err) override;
+    Error status(const char *status, const char *args) override;
 
 private:
     std::vector< std::pair<std::string, std::string> > m_status;
     std::string m_data;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_DEFAULTASSUANTRANSACTION_H__
diff --git a/lang/cpp/src/editinteractor.cpp b/lang/cpp/src/editinteractor.cpp
index 3e294889..f7c994a4 100644
--- a/lang/cpp/src/editinteractor.cpp
+++ b/lang/cpp/src/editinteractor.cpp
@@ -1,347 +1,347 @@
 /*
   editinteractor.cpp - Interface for edit interactors
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "editinteractor.h"
 #include "callbacks.h"
 #include "error.h"
 
 #include <gpgme.h>
 
 #ifdef _WIN32
 # include <io.h>
 #include <windows.h>
 #else
 # include <unistd.h>
 #endif
 
 #include <cerrno>
 #include <cstring>
 
 #ifndef GPG_ERR_ALREADY_SIGNED
 # define GPG_ERR_ALREADY_SIGNED GPG_ERR_USER_1
 #endif
 
 using namespace GpgME;
 
 static const char *status_to_string(unsigned int status);
 static Error status_to_error(unsigned int status);
 
 class EditInteractor::Private
 {
     friend class ::GpgME::EditInteractor;
     friend class ::GpgME::CallbackHelper;
     EditInteractor *const q;
 public:
     explicit Private(EditInteractor *qq);
     ~Private();
 
 private:
     unsigned int state;
     Error error;
     std::FILE *debug;
 };
 
 class GpgME::CallbackHelper
 {
 private:
     static int writeAll(int fd, const void *buf, size_t count)
     {
         size_t toWrite = count;
         while (toWrite > 0) {
             const int n = gpgme_io_write(fd, buf, toWrite);
             if (n < 0) {
                 return n;
             }
             toWrite -= n;
         }
         return count;
     }
 
 public:
     static int edit_interactor_callback_impl(void *opaque, gpgme_status_code_t status, const char *args, int fd)
     {
         EditInteractor::Private *ei = (EditInteractor::Private *)opaque;
 
         Error err = status_to_error(status);
 
         if (!err) {
 
             // advance to next state based on input:
             const unsigned int oldState = ei->state;
             ei->state = ei->q->nextState(status, args, err);
             if (ei->debug) {
                 std::fprintf(ei->debug, "EditInteractor: %u -> nextState( %s, %s ) -> %u\n",
                              oldState, status_to_string(status), args ? args : "<null>", ei->state);
             }
             if (err) {
                 ei->state = oldState;
                 goto error;
             }
 
             if (ei->state != oldState &&
                     // if there was an error from before, we stop here (### this looks weird, can this happen at all?)
                     ei->error.code() == GPG_ERR_NO_ERROR) {
 
                 // successful state change -> call action
                 if (const char *const result = ei->q->action(err)) {
                     if (err) {
                         goto error;
                     }
                     if (ei->debug) {
                         std::fprintf(ei->debug, "EditInteractor: action result \"%s\"\n", result);
                     }
                     // if there's a result, write it:
                     if (*result) {
                         gpgme_err_set_errno(0);
                         const ssize_t len = std::strlen(result);
                         if (writeAll(fd, result, len) != len) {
                             err = Error::fromSystemError();
                             if (ei->debug) {
                                 std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString());
                             }
                             goto error;
                         }
                     }
                     gpgme_err_set_errno(0);
                     if (writeAll(fd, "\n", 1) != 1) {
                         err = Error::fromSystemError();
                         if (ei->debug) {
                             std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString());
                         }
                         goto error;
                     }
                 } else {
                     if (err) {
                         goto error;
                     }
                     if (ei->debug) {
                         std::fprintf(ei->debug, "EditInteractor: no action result\n");
                     }
                 }
             } else {
                 if (ei->debug) {
                     std::fprintf(ei->debug, "EditInteractor: no action executed\n");
                 }
             }
         }
 
     error:
         if (err) {
             ei->error = err;
             ei->state = EditInteractor::ErrorState;
         }
 
         if (ei->debug) {
             std::fprintf(ei->debug, "EditInteractor: error now %u (%s)\n",
                          ei->error.encodedError(), gpgme_strerror(ei->error.encodedError()));
         }
 
         return ei->error.encodedError();
     }
 };
 
 static gpgme_error_t edit_interactor_callback(void *opaque, gpgme_status_code_t status, const char *args, int fd)
 {
     return CallbackHelper::edit_interactor_callback_impl(opaque, status, args, fd);
 }
 
 const gpgme_edit_cb_t GpgME::edit_interactor_callback = ::edit_interactor_callback;
 
 EditInteractor::Private::Private(EditInteractor *qq)
     : q(qq),
       state(StartState),
       error(),
-      debug(0)
+      debug(nullptr)
 {
 
 }
 
 EditInteractor::Private::~Private() {}
 
 EditInteractor::EditInteractor()
     : d(new Private(this))
 {
 
 }
 
 EditInteractor::~EditInteractor()
 {
     delete d;
 }
 
 unsigned int EditInteractor::state() const
 {
     return d->state;
 }
 
 Error EditInteractor::lastError() const
 {
     return d->error;
 }
 
 bool EditInteractor::needsNoResponse(unsigned int status) const
 {
     switch (status) {
     case GPGME_STATUS_ALREADY_SIGNED:
     case GPGME_STATUS_ERROR:
     case GPGME_STATUS_GET_BOOL:
     case GPGME_STATUS_GET_LINE:
     case GPGME_STATUS_KEY_CREATED:
     case GPGME_STATUS_NEED_PASSPHRASE_SYM:
     case GPGME_STATUS_SC_OP_FAILURE:
     case GPGME_STATUS_CARDCTRL:
     case GPGME_STATUS_BACKUP_KEY_CREATED:
         return false;
     default:
         return true;
     }
 }
 
 // static
 Error status_to_error(unsigned int status)
 {
     switch (status) {
     case GPGME_STATUS_MISSING_PASSPHRASE:
         return Error::fromCode(GPG_ERR_NO_PASSPHRASE);
     case GPGME_STATUS_ALREADY_SIGNED:
         return Error::fromCode(GPG_ERR_ALREADY_SIGNED);
     case GPGME_STATUS_SIGEXPIRED:
         return Error::fromCode(GPG_ERR_SIG_EXPIRED);
     }
     return Error();
 }
 
 void EditInteractor::setDebugChannel(std::FILE *debug)
 {
     d->debug = debug;
 }
 
 static const char *const status_strings[] = {
     "EOF",
     /* mkstatus processing starts here */
     "ENTER",
     "LEAVE",
     "ABORT",
 
     "GOODSIG",
     "BADSIG",
     "ERRSIG",
 
     "BADARMOR",
 
     "RSA_OR_IDEA",
     "KEYEXPIRED",
     "KEYREVOKED",
 
     "TRUST_UNDEFINED",
     "TRUST_NEVER",
     "TRUST_MARGINAL",
     "TRUST_FULLY",
     "TRUST_ULTIMATE",
 
     "SHM_INFO",
     "SHM_GET",
     "SHM_GET_BOOL",
     "SHM_GET_HIDDEN",
 
     "NEED_PASSPHRASE",
     "VALIDSIG",
     "SIG_ID",
     "ENC_TO",
     "NODATA",
     "BAD_PASSPHRASE",
     "NO_PUBKEY",
     "NO_SECKEY",
     "NEED_PASSPHRASE_SYM",
     "DECRYPTION_FAILED",
     "DECRYPTION_OKAY",
     "MISSING_PASSPHRASE",
     "GOOD_PASSPHRASE",
     "GOODMDC",
     "BADMDC",
     "ERRMDC",
     "IMPORTED",
     "IMPORT_OK",
     "IMPORT_PROBLEM",
     "IMPORT_RES",
     "FILE_START",
     "FILE_DONE",
     "FILE_ERROR",
 
     "BEGIN_DECRYPTION",
     "END_DECRYPTION",
     "BEGIN_ENCRYPTION",
     "END_ENCRYPTION",
 
     "DELETE_PROBLEM",
     "GET_BOOL",
     "GET_LINE",
     "GET_HIDDEN",
     "GOT_IT",
     "PROGRESS",
     "SIG_CREATED",
     "SESSION_KEY",
     "NOTATION_NAME",
     "NOTATION_DATA",
     "POLICY_URL",
     "BEGIN_STREAM",
     "END_STREAM",
     "KEY_CREATED",
     "USERID_HINT",
     "UNEXPECTED",
     "INV_RECP",
     "NO_RECP",
     "ALREADY_SIGNED",
     "SIGEXPIRED",
     "EXPSIG",
     "EXPKEYSIG",
     "TRUNCATED",
     "ERROR",
     "NEWSIG",
     "REVKEYSIG",
     "SIG_SUBPACKET",
     "NEED_PASSPHRASE_PIN",
     "SC_OP_FAILURE",
     "SC_OP_SUCCESS",
     "CARDCTRL",
     "BACKUP_KEY_CREATED",
     "PKA_TRUST_BAD",
     "PKA_TRUST_GOOD",
 
     "PLAINTEXT",
 };
 static const unsigned int num_status_strings = sizeof status_strings / sizeof * status_strings ;
 
 const char *status_to_string(unsigned int idx)
 {
     if (idx < num_status_strings) {
         return status_strings[idx];
     } else {
         return "(unknown)";
     }
 }
diff --git a/lang/cpp/src/encryptionresult.cpp b/lang/cpp/src/encryptionresult.cpp
index 33365cd4..95dcb22e 100644
--- a/lang/cpp/src/encryptionresult.cpp
+++ b/lang/cpp/src/encryptionresult.cpp
@@ -1,165 +1,165 @@
 /*
   encryptionresult.cpp - wraps a gpgme verify result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <encryptionresult.h>
 #include "result_p.h"
 #include "util.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 #include <cstdlib>
 #include <istream>
 #include <algorithm>
 #include <iterator>
 
 #include <string.h>
 
 class GpgME::EncryptionResult::Private
 {
 public:
     explicit Private(const gpgme_encrypt_result_t r)
     {
         if (!r) {
             return;
         }
         for (gpgme_invalid_key_t ik = r->invalid_recipients ; ik ; ik = ik->next) {
             gpgme_invalid_key_t copy = new _gpgme_invalid_key(*ik);
             if (ik->fpr) {
                 copy->fpr = strdup(ik->fpr);
             }
-            copy->next = 0;
+            copy->next = nullptr;
             invalid.push_back(copy);
         }
     }
     ~Private()
     {
         for (std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it) {
             std::free((*it)->fpr);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
         }
     }
 
     std::vector<gpgme_invalid_key_t> invalid;
 };
 
 GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::EncryptionResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_encrypt_result_t res = gpgme_op_encrypt_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(res));
 }
 
 make_standard_stuff(EncryptionResult)
 
 unsigned int GpgME::EncryptionResult::numInvalidRecipients() const
 {
     return d ? d->invalid.size() : 0 ;
 }
 
 GpgME::InvalidRecipient GpgME::EncryptionResult::invalidEncryptionKey(unsigned int idx) const
 {
     return InvalidRecipient(d, idx);
 }
 
 std::vector<GpgME::InvalidRecipient> GpgME::EncryptionResult::invalidEncryptionKeys() const
 {
     if (!d) {
         return std::vector<GpgME::InvalidRecipient>();
     }
     std::vector<GpgME::InvalidRecipient> result;
     result.reserve(d->invalid.size());
     for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) {
         result.push_back(InvalidRecipient(d, i));
     }
     return result;
 }
 
 GpgME::InvalidRecipient::InvalidRecipient(const std::shared_ptr<EncryptionResult::Private> &parent, unsigned int i)
     : d(parent), idx(i)
 {
 
 }
 
 GpgME::InvalidRecipient::InvalidRecipient() : d(), idx(0) {}
 
 bool GpgME::InvalidRecipient::isNull() const
 {
     return !d || idx >= d->invalid.size() ;
 }
 
 const char *GpgME::InvalidRecipient::fingerprint() const
 {
-    return isNull() ? 0 : d->invalid[idx]->fpr ;
+    return isNull() ? nullptr : d->invalid[idx]->fpr ;
 }
 
 GpgME::Error GpgME::InvalidRecipient::reason() const
 {
     return Error(isNull() ? 0 : d->invalid[idx]->reason);
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const EncryptionResult &result)
 {
     os << "GpgME::EncryptionResult(";
     if (!result.isNull()) {
         os << "\n error:        " << result.error()
            << "\n invalid recipients:\n";
         const std::vector<InvalidRecipient> ir = result.invalidEncryptionKeys();
         std::copy(ir.begin(), ir.end(),
                   std::ostream_iterator<InvalidRecipient>(os, "\n"));
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const InvalidRecipient &ir)
 {
     os << "GpgME::InvalidRecipient(";
     if (!ir.isNull()) {
         os << "\n fingerprint: " << protect(ir.fingerprint())
            << "\n reason:      " << ir.reason()
            << '\n';
     }
     return os << ')';
 }
diff --git a/lang/cpp/src/engineinfo.cpp b/lang/cpp/src/engineinfo.cpp
index 1a66ced2..c4ad5300 100644
--- a/lang/cpp/src/engineinfo.cpp
+++ b/lang/cpp/src/engineinfo.cpp
@@ -1,94 +1,94 @@
 /*
   engineinfo.h
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "engineinfo.h"
 
 #include <gpgme.h>
 
 class GpgME::EngineInfo::Private
 {
 public:
-    Private(gpgme_engine_info_t engine = 0) : info(engine) {}
+    Private(gpgme_engine_info_t engine = nullptr) : info(engine) {}
     ~Private()
     {
-        info = 0;
+        info = nullptr;
     }
 
     gpgme_engine_info_t info;
 };
 
 GpgME::EngineInfo::EngineInfo() : d() {}
 
 GpgME::EngineInfo::EngineInfo(gpgme_engine_info_t engine)
     : d(new Private(engine))
 {
 
 }
 
 bool GpgME::EngineInfo::isNull() const
 {
     return !d || !d->info;
 }
 
 GpgME::Protocol GpgME::EngineInfo::protocol() const
 {
     if (isNull()) {
         return UnknownProtocol;
     }
     switch (d->info->protocol) {
     case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
     case GPGME_PROTOCOL_CMS:     return CMS;
     default:
         return UnknownProtocol;
     }
 }
 
 const char *GpgME::EngineInfo::fileName() const
 {
-    return isNull() ? 0 : d->info->file_name;
+    return isNull() ? nullptr : d->info->file_name;
 }
 
 const char *GpgME::EngineInfo::version() const
 {
-    return isNull() ? 0 : d->info->version;
+    return isNull() ? nullptr : d->info->version;
 }
 
 GpgME::EngineInfo::Version GpgME::EngineInfo::engineVersion() const
 {
     return Version(version());
 }
 
 const char *GpgME::EngineInfo::requiredVersion() const
 {
-    return isNull() ? 0 : d->info->req_version;
+    return isNull() ? nullptr : d->info->req_version;
 }
 
 const char *GpgME::EngineInfo::homeDirectory() const
 {
-    return isNull() ? 0 : d->info->home_dir;
+    return isNull() ? nullptr : d->info->home_dir;
 }
diff --git a/lang/cpp/src/eventloopinteractor.cpp b/lang/cpp/src/eventloopinteractor.cpp
index a30b793c..09710ad4 100644
--- a/lang/cpp/src/eventloopinteractor.cpp
+++ b/lang/cpp/src/eventloopinteractor.cpp
@@ -1,205 +1,205 @@
 /*
   eventloopinteractor.cpp
   Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <eventloopinteractor.h>
 
 #include <context.h>
 #include "context_p.h"
 #include <key.h>
 #include <trustitem.h>
 
 #include <gpgme.h>
 
 #include <vector>
 using std::vector;
 #ifndef NDEBUG
 # include <iostream>
 #endif
 #include <cassert>
 
 namespace GpgME
 {
 
 //
 // EventLoopInteractor::Private Declaration
 //
 
 class EventLoopInteractor::Private
 {
 public:
     struct OneFD {
         OneFD(int aFd, int aDir, gpgme_io_cb_t aFnc,
               void *aFncData, void *aExternalTag)
             : fd(aFd), dir(aDir), fnc(aFnc),
               fncData(aFncData), externalTag(aExternalTag) {}
         int fd;
         int dir;
         gpgme_io_cb_t fnc;
         void *fncData;
         void *externalTag;
     };
 
     vector<OneFD *> mCallbacks;
 
     static void removeIOCb(void *tag);
     static gpgme_error_t registerIOCb(void *data, int fd, int dir,
                                       gpgme_io_cb_t fnc, void *fnc_data,
                                       void **r_tag);
     static void eventIOCb(void *, gpgme_event_io_t type, void *type_data);
 
     static const gpgme_io_cbs iocbs;
 };
 
 const gpgme_io_cbs EventLoopInteractor::Private::iocbs = {
     &EventLoopInteractor::Private::registerIOCb,
-    0,
+    nullptr,
     &EventLoopInteractor::Private::removeIOCb,
     &EventLoopInteractor::Private::eventIOCb,
-    0
+    nullptr
 };
 
 //
 // EventLoopInteractor::Private IO Callback Implementations
 //
 
 gpgme_error_t EventLoopInteractor::Private::registerIOCb(void *, int fd, int dir,
         gpgme_io_cb_t fnc, void *fnc_data,
         void **r_tag)
 {
     assert(instance()); assert(instance()->d);
     bool ok = false;
     void *etag = instance()->registerWatcher(fd, dir ? Read : Write, ok);
     if (!ok) {
         return gpgme_error(GPG_ERR_GENERAL);
     }
     instance()->d->mCallbacks.push_back(new OneFD(fd, dir, fnc, fnc_data, etag));
     if (r_tag) {
         *r_tag = instance()->d->mCallbacks.back();
     }
     return GPG_ERR_NO_ERROR;
 }
 
 void EventLoopInteractor::Private::removeIOCb(void *tag)
 {
 
     if (!instance() || !instance()->d) {
         return;
     }
     for (vector<OneFD *>::iterator it = instance()->d->mCallbacks.begin();
             it != instance()->d->mCallbacks.end() ; ++it) {
         if (*it == tag) {
             instance()->unregisterWatcher((*it)->externalTag);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
             instance()->d->mCallbacks.erase(it);
             return;
         }
     }
 }
 
 void EventLoopInteractor::Private::eventIOCb(void *data, gpgme_event_io_t type, void *type_data)
 {
     assert(instance());
     Context *ctx = static_cast<Context *>(data);
     switch (type) {
     case GPGME_EVENT_START: {
         instance()->operationStartEvent(ctx);
         // TODO: what's in type_data?
     }
     break;
     case GPGME_EVENT_DONE: {
         gpgme_error_t e = *static_cast<gpgme_error_t *>(type_data);
         if (ctx && ctx->impl()) {
             ctx->impl()->lasterr = e;
         }
         instance()->operationDoneEvent(ctx, Error(e));
     }
     break;
     case GPGME_EVENT_NEXT_KEY: {
         gpgme_key_t key = static_cast<gpgme_key_t>(type_data);
         instance()->nextKeyEvent(ctx, Key(key, false));
     }
     break;
     case GPGME_EVENT_NEXT_TRUSTITEM: {
         gpgme_trust_item_t item = static_cast<gpgme_trust_item_t>(type_data);
         instance()->nextTrustItemEvent(ctx, TrustItem(item));
         gpgme_trust_item_unref(item);
     }
     break;
     default: // warn
         ;
     }
 }
 
 //
 // EventLoopInteractor Implementation
 //
 
-EventLoopInteractor *EventLoopInteractor::mSelf = 0;
+EventLoopInteractor *EventLoopInteractor::mSelf = nullptr;
 
 EventLoopInteractor::EventLoopInteractor() : d(new Private)
 {
     assert(!mSelf);
     mSelf = this;
 }
 
 EventLoopInteractor::~EventLoopInteractor()
 {
     // warn if there are still callbacks registered
-    mSelf = 0;
+    mSelf = nullptr;
     delete d;
 }
 
 void EventLoopInteractor::manage(Context *context)
 {
     if (!context || context->managedByEventLoopInteractor()) {
         return;
     }
     gpgme_io_cbs *iocbs = new gpgme_io_cbs(Private::iocbs);
     iocbs->event_priv = context;
     context->installIOCallbacks(iocbs);
 }
 
 void EventLoopInteractor::unmanage(Context *context)
 {
     if (context) {
         context->uninstallIOCallbacks();
     }
 }
 
 void EventLoopInteractor::actOn(int fd, Direction dir)
 {
     for (vector<Private::OneFD *>::const_iterator it = d->mCallbacks.begin();
             it != d->mCallbacks.end() ; ++it) {
         if ((*it)->fd == fd && ((*it)->dir ? Read : Write) == dir) {
             (*((*it)->fnc))((*it)->fncData, fd);
             break;
         }
     }
 }
 
 } // namespace GpgME
diff --git a/lang/cpp/src/global.h b/lang/cpp/src/global.h
index e303c49a..9760e215 100644
--- a/lang/cpp/src/global.h
+++ b/lang/cpp/src/global.h
@@ -1,221 +1,221 @@
 /*
   global.h - global gpgme functions and enums
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_GLOBAL_H__
 #define __GPGMEPP_GLOBAL_H__
 
 #include "gpgmefw.h"
 #include "gpgmepp_export.h"
 
 #include <iosfwd>
 #include <cstring>
 
 namespace GpgME
 {
 class Error;
 class EngineInfo;
 class Context;
 }
 
 struct _GIOChannel;
 typedef struct _GIOChannel      GIOChannel;
 class QIODevice;
 
 namespace GpgME
 {
 
 GPGMEPP_EXPORT void initializeLibrary();
 /*!
   Initializes the library, returns Error::code() ==
   GPG_ERR_USER_1 if underlying gpgme is too old.
 */
 GPGMEPP_EXPORT Error initializeLibrary(int);
 
 enum Protocol { OpenPGP, CMS, UnknownProtocol };
 
 enum Engine { GpgEngine, GpgSMEngine, GpgConfEngine, UnknownEngine, AssuanEngine, G13Engine, SpawnEngine };
 
 enum KeyListMode {
     Local = 0x1,
     Extern = 0x2,
     Locate = 0x3,
     Signatures = 0x4,
     SignatureNotations = 0x8,
     Validate = 0x10,
     Ephemeral = 0x20,
     WithTofu = 0x40
 };
 
 enum SignatureMode { NormalSignatureMode, Detached, Clearsigned };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Protocol proto);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Engine eng);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, KeyListMode mode);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, SignatureMode mode);
 
 GPGMEPP_EXPORT Error setDefaultLocale(int category, const char *value);
 
 GPGMEPP_EXPORT Context *wait(Error &e, bool hang = true);
 typedef void (*IdleFunction)(void);
 GPGMEPP_EXPORT IdleFunction registerIdleFunction(IdleFunction idleFunction);
 
 typedef void (*IOCallback)(void *data, int fd);
 
 GPGMEPP_EXPORT EngineInfo engineInfo(Protocol proto);
 GPGMEPP_EXPORT EngineInfo engineInfo(Engine engine);
 /** Wrapper around gpgme_get_dirinfo. What can be:
 homedir, sysconfdir, bindir, libexecdir, libdir,
 datadir, localedir, agent-socket, agent-ssh-socket,
 dirmngr-socket, uiserver-socket, gpgconf-name, gpg-name,
 gpgsm-name, g13-name
 
 This may be extended in the future.
 */
 GPGMEPP_EXPORT const char *dirInfo(const char *what);
 
 GPGMEPP_EXPORT Error checkEngine(Protocol proto);
 GPGMEPP_EXPORT Error checkEngine(Engine engine);
 
 GPGMEPP_EXPORT GIOChannel *getGIOChannel(int fd);
 GPGMEPP_EXPORT QIODevice   *getQIODevice(int fd);
 
 enum Feature {
     ValidatingKeylistModeFeature               = 0x00000001,
     CancelOperationFeature                     = 0x00000002,
     WrongKeyUsageFeature                       = 0x00000004,
     DefaultCertificateInclusionFeature         = 0x00000008,
 
     GetSetEngineInfoFeature                    = 0x00000010,
     EngineInfoHomeDirFeature                   = 0x00000020,
     NoEncryptToEncryptionFlagFeature           = 0x00000040,
     EphemeralKeylistModeFeature                = 0x00000080,
 
     SetDataFileNameFeeature                    = 0x00000100,
     VerificationResultFileNameFeature          = 0x00000200,
     DecryptionResultFileNameFeature            = 0x00000400,
     DecryptionResultRecipientsFeature          = 0x00000800,
 
     AuditLogFeature                            = 0x00001000,
     GpgConfEngineFeature                       = 0x00002000,
     CancelOperationAsyncFeature                = 0x00004000,
     AssuanEngineFeature                        = 0x00008000,
 
     ClearAddGetSignatureNotationsFeature       = 0x00010000,
     SignatureNotationsKeylistModeFeature       = 0x00020000,
     KeySignatureNotationsFeature               = 0x00040000,
     SignatureNotationsFlagsFeature             = 0x00080000,
     SignatureNotationsCriticalFlagFeature      = 0x00100000,
     SignatureNotationsHumanReadableFlagFeature = 0x00200000,
     CardKeyFeature                             = 0x00400000,
     ImportFromKeyserverFeature                 = 0x00800000,
 
     KeyIsQualifiedFeature                      = 0x01000200,
     SubkeyIsQualifiedFeature                   = 0x02000000,
     SignaturePkaFieldsFeature                  = 0x04000000,
     SignatureAlgorithmFieldsFeature            = 0x08000000,
 
     FdPointerFeature                           = 0x10000000,
     G13VFSFeature                              = 0x20000000,
     PasswdFeature                              = 0x40000000, // gpgme >= 1.3.0
     // unusable (max value)
 
     FeatureMaxValue                            = 0x80000000
 };
 enum Feature2 {
     BinaryAndFineGrainedIdentify               = 0x00000001, // gpgme >= 1.7.0
     Feature2MaxValue                           = 0x80000000
 };
 
 // use hasFeature( unsigned long, unsigned long ) instead
 GPGMEPP_DEPRECATED_EXPORT bool hasFeature(unsigned long feature);
 GPGMEPP_EXPORT bool hasFeature(unsigned long feature, unsigned long feature2);
 
 } // namespace GpgME
 
 # ifndef GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION
 #  define GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION( Class ) \
     namespace std { template <> inline void swap< GpgME::Class >( GpgME::Class & lhs, GpgME::Class & rhs ) { lhs.swap( rhs ); } }
 # endif
 
 # ifndef GPGMEPP_MAKE_SAFE_BOOL_OPERATOR
 #  define GPGMEPP_MAKE_SAFE_BOOL_OPERATOR( Cond ) \
     private: \
     struct __safe_bool_dummy__ { void nonnull() {} }; \
     typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \
     public: \
-    operator unspecified_bool_type() const { return ( Cond ) ? &__safe_bool_dummy__::nonnull : 0 ; }
+    operator unspecified_bool_type() const { return ( Cond ) ? &__safe_bool_dummy__::nonnull : nullptr; }
 # endif
 
 inline int _gpgmepp_strcmp(const char *s1, const char *s2)
 {
     return s1 ? s2 ? std::strcmp(s1, s2) : 1 : s2 ? -1 : 0;
 }
 
 #define _GPGMEPP_MAKE_STRCMP( Name, expr, cmp )                     \
     template <template <typename U> class Op>                           \
     struct Name {                                                       \
         typedef bool result_type;                                       \
         \
         bool operator()( const char * lhs, const char * rhs ) const {   \
             return Op<int>()( cmp, 0 );                                 \
         }                                                               \
         \
         bool operator()( const std::string & lhs, const std::string & rhs ) const { \
             return operator()( lhs.c_str(), rhs.c_str() );              \
         }                                                               \
         bool operator()( const char * lhs, const std::string & rhs ) const { \
             return operator()( lhs, rhs.c_str() );                      \
         }                                                               \
         bool operator()( const std::string & lhs, const char * rhs ) const { \
             return operator()( lhs.c_str(), rhs );                      \
         }                                                               \
         \
         template <typename T>                                           \
         bool operator()( const T & lhs, const T & rhs ) const {         \
             return operator()( (lhs expr), (rhs expr) );                \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const char * rhs ) const {      \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const char * lhs, const T & rhs ) const {      \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const std::string & rhs ) const { \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const std::string & lhs, const T & rhs ) const {    \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
     }
 
 #define GPGMEPP_MAKE_STRCMP( Name, expr )                          \
     _GPGMEPP_MAKE_STRCMP( Name, expr, _gpgmepp_strcmp( lhs, rhs ) )
 
 
 #endif // __GPGMEPP_GLOBAL_H__
diff --git a/lang/cpp/src/gpgadduserideditinteractor.cpp b/lang/cpp/src/gpgadduserideditinteractor.cpp
index 593ac58e..c26f5593 100644
--- a/lang/cpp/src/gpgadduserideditinteractor.cpp
+++ b/lang/cpp/src/gpgadduserideditinteractor.cpp
@@ -1,195 +1,195 @@
 /*
   gpgadduserideditinteractor.cpp - Edit Interactor to add a new UID to an OpenPGP key
   Copyright (C) 2008 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "gpgadduserideditinteractor.h"
 
 #include "error.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 
 using std::strcmp;
 
 // avoid conflict (msvc)
 #ifdef ERROR
 # undef ERROR
 #endif
 
 using namespace GpgME;
 
 GpgAddUserIDEditInteractor::GpgAddUserIDEditInteractor()
     : EditInteractor(),
       m_name(),
       m_email(),
       m_comment()
 {
 
 }
 
 GpgAddUserIDEditInteractor::~GpgAddUserIDEditInteractor() {}
 
 void GpgAddUserIDEditInteractor::setNameUtf8(const std::string &name)
 {
     m_name = name;
 }
 
 void GpgAddUserIDEditInteractor::setEmailUtf8(const std::string &email)
 {
     m_email = email;
 }
 
 void GpgAddUserIDEditInteractor::setCommentUtf8(const std::string &comment)
 {
     m_comment = comment;
 }
 
 // work around --enable-final
 namespace GpgAddUserIDEditInteractor_Private
 {
 enum {
     START = EditInteractor::StartState,
     COMMAND,
     NAME,
     EMAIL,
     COMMENT,
     QUIT,
     SAVE,
 
     ERROR = EditInteractor::ErrorState
 };
 }
 
 const char *GpgAddUserIDEditInteractor::action(Error &err) const
 {
 
     using namespace GpgAddUserIDEditInteractor_Private;
 
     switch (state()) {
     case COMMAND:
         return "adduid";
     case NAME:
         return m_name.c_str();
     case EMAIL:
         return m_email.c_str();
     case COMMENT:
         return m_comment.c_str();
     case QUIT:
         return "quit";
     case SAVE:
         return "Y";
     case START:
     case ERROR:
-        return 0;
+        return nullptr;
     default:
         err = Error::fromCode(GPG_ERR_GENERAL);
-        return 0;
+        return nullptr;
     }
 }
 
 unsigned int GpgAddUserIDEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
 {
 
     static const Error GENERAL_ERROR     = Error::fromCode(GPG_ERR_GENERAL);
     static const Error INV_NAME_ERROR    = Error::fromCode(GPG_ERR_INV_NAME);
     static const Error INV_EMAIL_ERROR   = Error::fromCode(GPG_ERR_INV_USER_ID);
     static const Error INV_COMMENT_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID);
 
     if (needsNoResponse(status)) {
         return state();
     }
 
     using namespace GpgAddUserIDEditInteractor_Private;
 
     switch (state()) {
     case START:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return COMMAND;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case COMMAND:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.name") == 0) {
             return NAME;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case NAME:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.email") == 0) {
             return EMAIL;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.name") == 0) {
             err = INV_NAME_ERROR;
         }
         return ERROR;
     case EMAIL:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.comment") == 0) {
             return COMMENT;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.email") == 0) {
             err = INV_EMAIL_ERROR;
         }
         return ERROR;
     case COMMENT:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.comment") == 0) {
             err = INV_COMMENT_ERROR;
         }
         return ERROR;
     case QUIT:
         if (status == GPGME_STATUS_GET_BOOL &&
                 strcmp(args, "keyedit.save.okay") == 0) {
             return SAVE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case ERROR:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = lastError();
         return ERROR;
     default:
         err = GENERAL_ERROR;
         return ERROR;
     }
 }
diff --git a/lang/cpp/src/gpgadduserideditinteractor.h b/lang/cpp/src/gpgadduserideditinteractor.h
index 10cac08d..9d06f994 100644
--- a/lang/cpp/src/gpgadduserideditinteractor.h
+++ b/lang/cpp/src/gpgadduserideditinteractor.h
@@ -1,69 +1,69 @@
 /*
   gpgadduserideditinteractor.h - Edit Interactor to add a new UID to an OpenPGP key
   Copyright (C) 2008 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__
 #define __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__
 
 #include <editinteractor.h>
 
 #include <string>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT GpgAddUserIDEditInteractor : public EditInteractor
 {
 public:
     explicit GpgAddUserIDEditInteractor();
     ~GpgAddUserIDEditInteractor();
 
     void setNameUtf8(const std::string &name);
     const std::string &nameUtf8() const
     {
         return m_name;
     }
 
     void setEmailUtf8(const std::string &email);
     const std::string &emailUtf8() const
     {
         return m_email;
     }
 
     void setCommentUtf8(const std::string &comment);
     const std::string &commentUtf8() const
     {
         return m_comment;
     }
 
 private:
-    /* reimp */ const char *action(Error &err) const;
-    /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
+    const char *action(Error &err) const override;
+    unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const override;
 
 private:
     std::string m_name, m_email, m_comment;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__
diff --git a/lang/cpp/src/gpgagentgetinfoassuantransaction.h b/lang/cpp/src/gpgagentgetinfoassuantransaction.h
index 1bc50161..bbb5776b 100644
--- a/lang/cpp/src/gpgagentgetinfoassuantransaction.h
+++ b/lang/cpp/src/gpgagentgetinfoassuantransaction.h
@@ -1,75 +1,75 @@
 /*
   gpgagentgetinfoassuantransaction.h - Assuan Transaction to get information from gpg-agent
   Copyright (C) 2009 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__
 #define __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__
 
 #include <interfaces/assuantransaction.h>
 
 #include <string>
 #include <vector>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT GpgAgentGetInfoAssuanTransaction : public AssuanTransaction
 {
 public:
     enum InfoItem {
         Version,         // string
         Pid,             // unsigned long
         SocketName,      // string (path)
         SshSocketName,   // string (path)
         ScdRunning,      // (none, returns GPG_ERR_GENERAL when scdaemon isn't running)
         //CommandHasOption, // not supported
 
         LastInfoItem
     };
 
     explicit GpgAgentGetInfoAssuanTransaction(InfoItem item);
     ~GpgAgentGetInfoAssuanTransaction();
 
     std::string version() const;
     unsigned int pid() const;
     std::string socketName() const;
     std::string sshSocketName() const;
 
 private:
-    /* reimp */ const char *command() const;
-    /* reimp */ Error data(const char *data, size_t datalen);
-    /* reimp */ Data inquire(const char *name, const char *args, Error &err);
-    /* reimp */ Error status(const char *status, const char *args);
+    const char *command() const;
+    Error data(const char *data, size_t datalen) override;
+    Data inquire(const char *name, const char *args, Error &err) override;
+    Error status(const char *status, const char *args) override;
 
 private:
     void makeCommand() const;
 
 private:
     InfoItem m_item;
     mutable std::string m_command;
     std::string m_data;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__
diff --git a/lang/cpp/src/gpggencardkeyinteractor.cpp b/lang/cpp/src/gpggencardkeyinteractor.cpp
index 0ed6781a..831e4c4a 100644
--- a/lang/cpp/src/gpggencardkeyinteractor.cpp
+++ b/lang/cpp/src/gpggencardkeyinteractor.cpp
@@ -1,332 +1,332 @@
 /*
   gpggencardkeyinteractor.cpp - Edit Interactor to generate a key on a card
   Copyright (C) 2017 by Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "gpggencardkeyinteractor.h"
 
 #include "error.h"
 
 #include <gpgme.h>
 
 using namespace GpgME;
 
 class GpgGenCardKeyInteractor::Private
 {
 public:
     Private() : keysize("2048"), backup(false)
     {
 
     }
     std::string name, email, backupFileName, expiry, serial, keysize;
     bool backup;
 };
 
 GpgGenCardKeyInteractor::~GpgGenCardKeyInteractor() {}
 
 GpgGenCardKeyInteractor::GpgGenCardKeyInteractor(const std::string &serial):
     d(new Private)
 {
     d->serial = serial;
 }
 
 void GpgGenCardKeyInteractor::setNameUtf8(const std::string &name)
 {
     d->name = name;
 }
 
 void GpgGenCardKeyInteractor::setEmailUtf8(const std::string &email)
 {
     d->email = email;
 }
 
 void GpgGenCardKeyInteractor::setDoBackup(bool value)
 {
     d->backup = value;
 }
 
 void GpgGenCardKeyInteractor::setKeySize(int value)
 {
     d->keysize = std::to_string(value);
 }
 
 void GpgGenCardKeyInteractor::setExpiry(const std::string &timeStr)
 {
     d->expiry = timeStr;
 }
 
 std::string GpgGenCardKeyInteractor::backupFileName() const
 {
     return d->backupFileName;
 }
 
 namespace GpgGenCardKeyInteractor_Private
 {
 enum {
     START = EditInteractor::StartState,
     DO_ADMIN,
     EXPIRE,
 
     GOT_SERIAL,
     COMMAND,
     NAME,
     EMAIL,
     COMMENT,
     BACKUP,
     REPLACE,
     SIZE,
     SIZE2,
     SIZE3,
     BACKUP_KEY_CREATED,
     KEY_CREATED,
     QUIT,
     SAVE,
 
     ERROR = EditInteractor::ErrorState
 };
 }
 
 const char *GpgGenCardKeyInteractor::action(Error &err) const
 {
 
     using namespace GpgGenCardKeyInteractor_Private;
 
     switch (state()) {
     case DO_ADMIN:
         return "admin";
     case COMMAND:
         return "generate";
     case NAME:
         return d->name.c_str();
     case EMAIL:
         return d->email.c_str();
     case EXPIRE:
         return d->expiry.c_str();
     case BACKUP:
         return d->backup ? "Y" : "N";
     case REPLACE:
         return "Y";
     case SIZE:
     case SIZE2:
     case SIZE3:
         return d->keysize.c_str();
     case COMMENT:
         return "";
     case SAVE:
         return "Y";
     case QUIT:
         return "quit";
     case KEY_CREATED:
     case START:
     case GOT_SERIAL:
     case BACKUP_KEY_CREATED:
     case ERROR:
-        return 0;
+        return nullptr;
     default:
         err = Error::fromCode(GPG_ERR_GENERAL);
-        return 0;
+        return nullptr;
     }
 }
 
 unsigned int GpgGenCardKeyInteractor::nextState(unsigned int status, const char *args, Error &err) const
 {
 
     static const Error GENERAL_ERROR     = Error::fromCode(GPG_ERR_GENERAL);
     static const Error INV_NAME_ERROR    = Error::fromCode(GPG_ERR_INV_NAME);
     static const Error INV_EMAIL_ERROR   = Error::fromCode(GPG_ERR_INV_USER_ID);
     static const Error INV_COMMENT_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID);
 
     if (needsNoResponse(status)) {
         return state();
     }
 
     using namespace GpgGenCardKeyInteractor_Private;
 
     switch (state()) {
     case START:
         if (status == GPGME_STATUS_CARDCTRL &&
                 !d->serial.empty()) {
             const std::string sArgs = args;
             if (sArgs.find(d->serial) == std::string::npos) {
                 // Wrong smartcard
                 err = Error::fromCode(GPG_ERR_WRONG_CARD);
                 return ERROR;
             } else {
                 printf("EditInteractor: Confirmed S/N: %s %s\n",
                            d->serial.c_str(), sArgs.c_str());
             }
             return GOT_SERIAL;
         } else if (d->serial.empty()) {
             return GOT_SERIAL;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case GOT_SERIAL:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.prompt") == 0) {
             return DO_ADMIN;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case DO_ADMIN:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.prompt") == 0) {
             return COMMAND;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case COMMAND:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.genkeys.backup_enc") == 0) {
             return BACKUP;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case BACKUP:
         if (status == GPGME_STATUS_GET_BOOL &&
                 strcmp(args, "cardedit.genkeys.replace_keys") == 0) {
             return REPLACE;
         }
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.genkeys.size") == 0) {
             return SIZE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case REPLACE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.genkeys.size") == 0) {
             printf("Moving to SIZE\n");
             return SIZE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case SIZE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.genkeys.size") == 0) {
             return SIZE2;
         }
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.valid") == 0) {
             return EXPIRE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case SIZE2:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.genkeys.size") == 0) {
             return SIZE3;
         }
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.valid") == 0) {
             return EXPIRE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case SIZE3:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.valid") == 0) {
             return EXPIRE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case EXPIRE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.name") == 0) {
             return NAME;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case NAME:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.email") == 0) {
             return EMAIL;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.name") == 0) {
             err = INV_NAME_ERROR;
         }
         return ERROR;
     case EMAIL:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.comment") == 0) {
             return COMMENT;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.email") == 0) {
             err = INV_EMAIL_ERROR;
         }
         return ERROR;
     case COMMENT:
         if (status == GPGME_STATUS_BACKUP_KEY_CREATED) {
             std::string sArgs = args;
             const auto pos = sArgs.rfind(" ");
             if (pos != std::string::npos) {
                 d->backupFileName = sArgs.substr(pos + 1);
                 return BACKUP_KEY_CREATED;
             }
         }
         if (status == GPGME_STATUS_KEY_CREATED) {
             return KEY_CREATED;
         }
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = GENERAL_ERROR;
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.comment") == 0) {
             err = INV_COMMENT_ERROR;
         }
         return ERROR;
     case BACKUP_KEY_CREATED:
         if (status == GPGME_STATUS_KEY_CREATED) {
             return KEY_CREATED;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case KEY_CREATED:
         return QUIT;
     case QUIT:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "cardedit.prompt") == 0) {
             return QUIT;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case ERROR:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = lastError();
         return ERROR;
     default:
         err = GENERAL_ERROR;
         return ERROR;
     }
 }
diff --git a/lang/cpp/src/gpggencardkeyinteractor.h b/lang/cpp/src/gpggencardkeyinteractor.h
index 7cc22168..d6a7b7b0 100644
--- a/lang/cpp/src/gpggencardkeyinteractor.h
+++ b/lang/cpp/src/gpggencardkeyinteractor.h
@@ -1,72 +1,72 @@
 /*
   gpggencardkeyinteractor.h - Edit Interactor to generate a key on a card
   Copyright (C) 2017 by Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGGENCARDKEYEDITINTERACTOR_H__
 #define __GPGMEPP_GPGGENCARDKEYEDITINTERACTOR_H__
 
 #include <editinteractor.h>
 
 #include <string>
 #include <memory>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT GpgGenCardKeyInteractor: public EditInteractor
 {
 public:
     /** Edit interactor to generate a key on a smartcard.
      *
      * The \a serialnumber argument is intended to safeguard
      * against accidentally working on the wrong smartcard.
      *
      * The edit interactor will fail if the card did not match.
      *
      * @param serialnumber: Serialnumber of the intended card.
      **/
     explicit GpgGenCardKeyInteractor(const std::string &serialnumber);
     ~GpgGenCardKeyInteractor();
 
     /** Set the key sizes for the subkeys (default 2048) */
     void setKeySize(int size);
 
     void setNameUtf8(const std::string &name);
     void setEmailUtf8(const std::string &email);
 
     void setDoBackup(bool value);
     void setExpiry(const std::string &timeString);
 
     std::string backupFileName() const;
 
 private:
-    /* reimp */ const char *action(Error &err) const;
-    /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
+    const char *action(Error &err) const override;
+    unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const override;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGGENCARDKEYEDITINTERACTOR_H__
diff --git a/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp b/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp
index 7aebe73a..2936d194 100644
--- a/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp
+++ b/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp
@@ -1,147 +1,147 @@
 /*
   gpgsetexpirytimeeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "gpgsetexpirytimeeditinteractor.h"
 #include "error.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 
 using std::strcmp;
 
 // avoid conflict (msvc)
 #ifdef ERROR
 # undef ERROR
 #endif
 
 using namespace GpgME;
 
 GpgSetExpiryTimeEditInteractor::GpgSetExpiryTimeEditInteractor(const std::string &t)
     : EditInteractor(),
       m_strtime(t)
 {
 
 }
 
 GpgSetExpiryTimeEditInteractor::~GpgSetExpiryTimeEditInteractor() {}
 
 // work around --enable-final
 namespace GpgSetExpiryTimeEditInteractor_Private
 {
 enum {
     START = EditInteractor::StartState,
     COMMAND,
     DATE,
     QUIT,
     SAVE,
 
     ERROR = EditInteractor::ErrorState
 };
 }
 
 const char *GpgSetExpiryTimeEditInteractor::action(Error &err) const
 {
 
     using namespace GpgSetExpiryTimeEditInteractor_Private;
 
     switch (state()) {
     case COMMAND:
         return "expire";
     case DATE:
         return m_strtime.c_str();
     case QUIT:
         return "quit";
     case SAVE:
         return "Y";
     case START:
     case ERROR:
-        return 0;
+        return nullptr;
     default:
         err = Error::fromCode(GPG_ERR_GENERAL);
-        return 0;
+        return nullptr;
     }
 }
 
 unsigned int GpgSetExpiryTimeEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
 {
 
     static const Error GENERAL_ERROR  = Error::fromCode(GPG_ERR_GENERAL);
     static const Error INV_TIME_ERROR = Error::fromCode(GPG_ERR_INV_TIME);
 
     if (needsNoResponse(status)) {
         return state();
     }
 
     using namespace GpgSetExpiryTimeEditInteractor_Private;
 
     switch (state()) {
     case START:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return COMMAND;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case COMMAND:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keygen.valid") == 0) {
             return DATE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case DATE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         } else if (status == GPGME_STATUS_GET_LINE &&
                    strcmp(args, "keygen.valid")) {
             err = INV_TIME_ERROR;
             return ERROR;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case QUIT:
         if (status == GPGME_STATUS_GET_BOOL &&
                 strcmp(args, "keyedit.save.okay") == 0) {
             return SAVE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case ERROR:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = lastError();
         return ERROR;
     default:
         err = GENERAL_ERROR;
         return ERROR;
     }
 }
diff --git a/lang/cpp/src/gpgsetexpirytimeeditinteractor.h b/lang/cpp/src/gpgsetexpirytimeeditinteractor.h
index 6a4c7373..6c96b214 100644
--- a/lang/cpp/src/gpgsetexpirytimeeditinteractor.h
+++ b/lang/cpp/src/gpgsetexpirytimeeditinteractor.h
@@ -1,51 +1,51 @@
 /*
   gpgsetexpirytimeeditinteractor.h - Edit Interactor to change the expiry time of an OpenPGP key
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__
 #define __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__
 
 #include <editinteractor.h>
 
 #include <string>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT GpgSetExpiryTimeEditInteractor : public EditInteractor
 {
 public:
     explicit GpgSetExpiryTimeEditInteractor(const std::string &timeString = "0");
     ~GpgSetExpiryTimeEditInteractor();
 
 private:
-    /* reimp */ const char *action(Error &err) const;
-    /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
+    const char *action(Error &err) const override;
+    unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const override;
 
 private:
     const std::string m_strtime;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H___
diff --git a/lang/cpp/src/gpgsetownertrusteditinteractor.cpp b/lang/cpp/src/gpgsetownertrusteditinteractor.cpp
index 7525fd82..f1e99ea9 100644
--- a/lang/cpp/src/gpgsetownertrusteditinteractor.cpp
+++ b/lang/cpp/src/gpgsetownertrusteditinteractor.cpp
@@ -1,157 +1,157 @@
 /*
   gpgsetownertrusteditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "gpgsetownertrusteditinteractor.h"
 #include "error.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 
 using std::strcmp;
 
 // avoid conflict (msvc)
 #ifdef ERROR
 # undef ERROR
 #endif
 
 using namespace GpgME;
 
 GpgSetOwnerTrustEditInteractor::GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ot)
     : EditInteractor(),
       m_ownertrust(ot)
 {
 
 }
 
 GpgSetOwnerTrustEditInteractor::~GpgSetOwnerTrustEditInteractor() {}
 
 // work around --enable-final
 namespace GpgSetOwnerTrustEditInteractor_Private
 {
 enum {
     START = EditInteractor::StartState,
     COMMAND,
     VALUE,
     REALLY_ULTIMATE,
     QUIT,
     SAVE,
 
     ERROR = EditInteractor::ErrorState
 };
 }
 
 const char *GpgSetOwnerTrustEditInteractor::action(Error &err) const
 {
     static const char truststrings[][2] = { "1", "1", "2", "3", "4", "5" };
 
     using namespace GpgSetOwnerTrustEditInteractor_Private;
 
     switch (state()) {
     case COMMAND:
         return "trust";
     case VALUE:
         return truststrings[m_ownertrust];
     case REALLY_ULTIMATE:
         return "Y";
     case QUIT:
         return "quit";
     case SAVE:
         return "Y";
     case START:
     case ERROR:
-        return 0;
+        return nullptr;
     default:
         err = Error::fromCode(GPG_ERR_GENERAL);
-        return 0;
+        return nullptr;
     }
 }
 
 unsigned int GpgSetOwnerTrustEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
 {
 
     static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
     //static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME );
 
     if (needsNoResponse(status)) {
         return state();
     }
 
     using namespace GpgSetOwnerTrustEditInteractor_Private;
 
     switch (state()) {
     case START:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return COMMAND;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case COMMAND:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "edit_ownertrust.value") == 0) {
             return VALUE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case VALUE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         } else if (status == GPGME_STATUS_GET_BOOL &&
                    strcmp(args, "edit_ownertrust.set_ultimate.okay") == 0) {
             return REALLY_ULTIMATE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case REALLY_ULTIMATE:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case QUIT:
         if (status == GPGME_STATUS_GET_BOOL &&
                 strcmp(args, "keyedit.save.okay") == 0) {
             return SAVE;
         }
         err = GENERAL_ERROR;
         return ERROR;
     case ERROR:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             return QUIT;
         }
         err = lastError();
         return ERROR;
     default:
         err = GENERAL_ERROR;
         return ERROR;
     };
 }
diff --git a/lang/cpp/src/gpgsetownertrusteditinteractor.h b/lang/cpp/src/gpgsetownertrusteditinteractor.h
index 9cec77e7..b7f920be 100644
--- a/lang/cpp/src/gpgsetownertrusteditinteractor.h
+++ b/lang/cpp/src/gpgsetownertrusteditinteractor.h
@@ -1,52 +1,52 @@
 /*
   gpgsetownertrusteditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__
 #define __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__
 
 #include <editinteractor.h>
 #include <key.h>
 
 #include <string>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT GpgSetOwnerTrustEditInteractor : public EditInteractor
 {
 public:
     explicit GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ownertrust);
     ~GpgSetOwnerTrustEditInteractor();
 
 private:
-    /* reimp */ const char *action(Error &err) const;
-    /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
+    const char *action(Error &err) const override;
+    unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const override;
 
 private:
     const Key::OwnerTrust m_ownertrust;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__
diff --git a/lang/cpp/src/gpgsignkeyeditinteractor.cpp b/lang/cpp/src/gpgsignkeyeditinteractor.cpp
index 79691bc2..295802db 100644
--- a/lang/cpp/src/gpgsignkeyeditinteractor.cpp
+++ b/lang/cpp/src/gpgsignkeyeditinteractor.cpp
@@ -1,328 +1,328 @@
 /*
   gpgsignkeyeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
   Copyright (C) 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "gpgsignkeyeditinteractor.h"
 #include "error.h"
 #include "key.h"
 
 #include <gpgme.h>
 
 #include <map>
 #include <string>
 #include <sstream>
 
 #include <cassert>
 #include <cstring>
 
 using std::strcmp;
 
 // avoid conflict (msvc)
 #ifdef ERROR
 # undef ERROR
 #endif
 
 #ifdef _MSC_VER
 #undef snprintf
 #define snprintf _snprintf
 #endif
 
 using namespace GpgME;
 
 class GpgSignKeyEditInteractor::Private
 {
 public:
     Private();
 
     std::string scratch;
     bool started;
     int options;
     std::vector<unsigned int> userIDs;
     std::vector<unsigned int>::const_iterator currentId, nextId;
     unsigned int checkLevel;
 
     const char *command() const
     {
         const bool local = (options & Exportable) == 0;
         const bool nonRevoc = options & NonRevocable;
         const bool trust = options & Trust;
         //TODO: check if all combinations are valid
         if (local && nonRevoc && trust) {
             return "ltnrsign";
         }
         if (local && nonRevoc) {
             return "lnrsign";
         }
         if (local && trust) {
             return "ltsign";
         }
         if (local) {
             return "lsign";
         }
         if (nonRevoc && trust) {
             return "tnrsign";
         }
         if (nonRevoc) {
             return "nrsign";
         }
         if (trust) {
             return "tsign";
         }
         return "sign";
     }
 
     bool signAll() const
     {
         return userIDs.empty();
     }
     unsigned int nextUserID()
     {
         assert(nextId != userIDs.end());
         currentId = nextId++;
         return currentUserID();
     }
 
     bool allUserIDsListed() const
     {
         return nextId == userIDs.end();
     }
 
     unsigned int currentUserID() const
     {
         assert(currentId != userIDs.end());
         return *currentId + 1;
     }
 
 };
 
 GpgSignKeyEditInteractor::Private::Private()
     :
     started(false),
     options(0),
     userIDs(),
     currentId(),
     nextId(),
     checkLevel(0)
 {
 }
 
 GpgSignKeyEditInteractor::GpgSignKeyEditInteractor()
     : EditInteractor(), d(new Private)
 {
 
 }
 
 GpgSignKeyEditInteractor::~GpgSignKeyEditInteractor()
 {
     delete d;
 }
 
 // work around --enable-final
 namespace GpgSignKeyEditInteractor_Private
 {
 enum SignKeyState {
     START = EditInteractor::StartState,
     COMMAND,
     UIDS_ANSWER_SIGN_ALL,
     UIDS_LIST_SEPARATELY,
     // all these free slots belong to UIDS_LIST_SEPARATELY, too
     // (we increase state() by one for each UID, so that action() is called)
     UIDS_LIST_SEPARATELY_DONE = 1000000,
     SET_EXPIRE,
     SET_CHECK_LEVEL,
     SET_TRUST_VALUE,
     SET_TRUST_DEPTH,
     SET_TRUST_REGEXP,
     CONFIRM,
     CONFIRM2,
     QUIT,
     SAVE,
     ERROR = EditInteractor::ErrorState
 };
 
 typedef std::map<std::tuple<SignKeyState, unsigned int, std::string>, SignKeyState> TransitionMap;
 
 }
 
 static const char *answer(bool b)
 {
     return b ? "Y" : "N";
 }
 
 static GpgSignKeyEditInteractor_Private::TransitionMap makeTable()
 {
     using namespace GpgSignKeyEditInteractor_Private;
     TransitionMap tab;
     const unsigned int GET_BOOL = GPGME_STATUS_GET_BOOL;
     const unsigned int GET_LINE = GPGME_STATUS_GET_LINE;
 #define addEntry( s1, status, str, s2 ) tab[std::make_tuple( s1, status, str)] = s2
     addEntry(START, GET_LINE, "keyedit.prompt", COMMAND);
     addEntry(COMMAND, GET_BOOL, "keyedit.sign_all.okay", UIDS_ANSWER_SIGN_ALL);
     addEntry(COMMAND, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(COMMAND, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM2);
     addEntry(UIDS_ANSWER_SIGN_ALL, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.expire", SET_EXPIRE);
     addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
     addEntry(SET_TRUST_VALUE, GET_LINE, "trustsign_prompt.trust_depth", SET_TRUST_DEPTH);
     addEntry(SET_TRUST_DEPTH, GET_LINE, "trustsign_prompt.trust_regexp", SET_TRUST_REGEXP);
     addEntry(SET_TRUST_REGEXP, GET_LINE, "sign_uid.okay", CONFIRM);
     addEntry(SET_CHECK_LEVEL, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(SET_EXPIRE, GET_BOOL, "sign_uid.class", SET_CHECK_LEVEL);
     addEntry(CONFIRM, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM);
     addEntry(CONFIRM, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(CONFIRM2, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(CONFIRM, GET_LINE, "keyedit.prompt", COMMAND);
     addEntry(CONFIRM, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE);
     addEntry(CONFIRM, GET_LINE, "sign_uid.expire", SET_EXPIRE);
     addEntry(CONFIRM, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "keyedit.prompt", COMMAND);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.expire", SET_EXPIRE);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
     addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.okay", CONFIRM);
     addEntry(CONFIRM, GET_LINE, "keyedit.prompt", QUIT);
     addEntry(ERROR, GET_LINE, "keyedit.prompt", QUIT);
     addEntry(QUIT, GET_BOOL, "keyedit.save.okay", SAVE);
 #undef addEntry
     return tab;
 }
 
 const char *GpgSignKeyEditInteractor::action(Error &err) const
 {
     static const char check_level_strings[][2] = { "0", "1", "2", "3" };
     using namespace GpgSignKeyEditInteractor_Private;
     using namespace std;
 
     switch (const unsigned int st = state()) {
     case COMMAND:
         return d->command();
     case UIDS_ANSWER_SIGN_ALL:
         return answer(d->signAll());
     case UIDS_LIST_SEPARATELY_DONE:
         return d->command();
     case SET_EXPIRE:
         return answer(true);
     case SET_TRUST_VALUE:
     // TODO
     case SET_TRUST_DEPTH:
     //TODO
     case SET_TRUST_REGEXP:
         //TODO
-        return 0;
+        return nullptr;
     case SET_CHECK_LEVEL:
         return check_level_strings[d->checkLevel];
     case CONFIRM2:
     case CONFIRM:
         return answer(true);
     case QUIT:
         return "quit";
     case SAVE:
         return answer(true);
     default:
         if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) {
             std::stringstream ss;
             ss << d->nextUserID();
             d->scratch = ss.str();
             return d->scratch.c_str();
         }
     // fall through
     case ERROR:
         err = Error::fromCode(GPG_ERR_GENERAL);
-        return 0;
+        return nullptr;
     }
 }
 
 unsigned int GpgSignKeyEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
 {
     d->started = true;
     using namespace GpgSignKeyEditInteractor_Private;
     static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
     //static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME );
     static const TransitionMap table(makeTable());
     if (needsNoResponse(status)) {
         return state();
     }
 
     using namespace GpgSignKeyEditInteractor_Private;
 
     //lookup transition in map
     const TransitionMap::const_iterator it = table.find(std::make_tuple(static_cast<SignKeyState>(state()), status, std::string(args)));
     if (it != table.end()) {
         return it->second;
     }
 
     //handle cases that cannot be handled via the map
     switch (const unsigned int st = state()) {
     case UIDS_ANSWER_SIGN_ALL:
         if (status == GPGME_STATUS_GET_LINE &&
                 strcmp(args, "keyedit.prompt") == 0) {
             if (!d->signAll()) {
                 return UIDS_LIST_SEPARATELY;
             }
             err = Error::fromCode(GPG_ERR_UNUSABLE_PUBKEY);
             return ERROR;
         }
         break;
     default:
         if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) {
             if (status == GPGME_STATUS_GET_LINE &&
                     strcmp(args, "keyedit.prompt") == 0) {
                 return d->allUserIDsListed() ? UIDS_LIST_SEPARATELY_DONE : st + 1 ;
             }
         }
         break;
     case CONFIRM:
     case ERROR:
         err = lastError();
         return ERROR;
     }
 
     err = GENERAL_ERROR;
     return ERROR;
 }
 
 void GpgSignKeyEditInteractor::setCheckLevel(unsigned int checkLevel)
 {
     assert(!d->started);
     assert(checkLevel <= 3);
     d->checkLevel = checkLevel;
 }
 
 void GpgSignKeyEditInteractor::setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign)
 {
     assert(!d->started);
     d->userIDs = userIDsToSign;
     d->nextId = d->userIDs.begin();
     d->currentId = d->userIDs.end();
 
 }
 void GpgSignKeyEditInteractor::setSigningOptions(int options)
 {
     assert(!d->started);
     d->options = options;
 }
diff --git a/lang/cpp/src/gpgsignkeyeditinteractor.h b/lang/cpp/src/gpgsignkeyeditinteractor.h
index f6cb4737..34b1f064 100644
--- a/lang/cpp/src/gpgsignkeyeditinteractor.h
+++ b/lang/cpp/src/gpgsignkeyeditinteractor.h
@@ -1,66 +1,66 @@
 /*
   gpgsignkeyeditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key
   Copyright (C) 2008 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__
 #define __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__
 
 #include <editinteractor.h>
 
 #include <string>
 #include <vector>
 
 namespace GpgME
 {
 
 class Key;
 class UserID;
 
 class GPGMEPP_EXPORT GpgSignKeyEditInteractor : public EditInteractor
 {
 public:
     enum SignOption {
         Exportable = 0x1,
         NonRevocable = 0x2,
         Trust = 0x4
     };
 
     GpgSignKeyEditInteractor();
     ~GpgSignKeyEditInteractor();
 
     void setCheckLevel(unsigned int checkLevel);
     void setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign);
     void setSigningOptions(int options);
 
 private:
-    /* reimp */ const char *action(Error &err) const;
-    /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
+    const char *action(Error &err) const override;
+    unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const override;
 
 private:
     class Private;
     Private *const d;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__
diff --git a/lang/cpp/src/importresult.cpp b/lang/cpp/src/importresult.cpp
index dbb31d05..05943ca0 100644
--- a/lang/cpp/src/importresult.cpp
+++ b/lang/cpp/src/importresult.cpp
@@ -1,226 +1,226 @@
 /*
   importresult.cpp - wraps a gpgme import result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <importresult.h>
 #include "result_p.h"
 
 #include <gpgme.h>
 #include <cstdlib>
 #include <cstring>
 
 #include <string.h>
 
 class GpgME::ImportResult::Private
 {
 public:
     Private(const _gpgme_op_import_result &r) : res(r)
     {
         // copy recursively, using compiler-generated copy ctor.
         // We just need to handle the pointers in the structs:
         for (gpgme_import_status_t is = r.imports ; is ; is = is->next) {
             gpgme_import_status_t copy = new _gpgme_import_status(*is);
             copy->fpr = strdup(is->fpr);
-            copy->next = 0;
+            copy->next = nullptr;
             imports.push_back(copy);
         }
-        res.imports = 0;
+        res.imports = nullptr;
     }
     ~Private()
     {
         for (std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it) {
             std::free((*it)->fpr);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
         }
     }
 
     _gpgme_op_import_result res;
     std::vector<gpgme_import_status_t> imports;
 };
 
 GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::ImportResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_import_result_t res = gpgme_op_import_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(*res));
 }
 
 make_standard_stuff(ImportResult)
 
 int GpgME::ImportResult::numConsidered() const
 {
     return d ? d->res.considered : 0 ;
 }
 
 int GpgME::ImportResult::numKeysWithoutUserID() const
 {
     return d ? d->res.no_user_id : 0 ;
 }
 
 int GpgME::ImportResult::numImported() const
 {
     return d ? d->res.imported : 0 ;
 }
 
 int GpgME::ImportResult::numRSAImported() const
 {
     return d ? d->res.imported_rsa : 0 ;
 }
 
 int GpgME::ImportResult::numUnchanged() const
 {
     return d ? d->res.unchanged : 0 ;
 }
 
 int GpgME::ImportResult::newUserIDs() const
 {
     return d ? d->res.new_user_ids : 0 ;
 }
 
 int GpgME::ImportResult::newSubkeys() const
 {
     return d ? d->res.new_sub_keys : 0 ;
 }
 
 int GpgME::ImportResult::newSignatures() const
 {
     return d ? d->res.new_signatures : 0 ;
 }
 
 int GpgME::ImportResult::newRevocations() const
 {
     return d ? d->res.new_revocations : 0 ;
 }
 
 int GpgME::ImportResult::numSecretKeysConsidered() const
 {
     return d ? d->res.secret_read : 0 ;
 }
 
 int GpgME::ImportResult::numSecretKeysImported() const
 {
     return d ? d->res.secret_imported : 0 ;
 }
 
 int GpgME::ImportResult::numSecretKeysUnchanged() const
 {
     return d ? d->res.secret_unchanged : 0 ;
 }
 
 int GpgME::ImportResult::notImported() const
 {
     return d ? d->res.not_imported : 0 ;
 }
 
 int GpgME::ImportResult::numV3KeysSkipped() const
 {
     return d ? d->res.skipped_v3_keys : 0 ;
 }
 
 GpgME::Import GpgME::ImportResult::import(unsigned int idx) const
 {
     return Import(d, idx);
 }
 
 std::vector<GpgME::Import> GpgME::ImportResult::imports() const
 {
     if (!d) {
         return std::vector<Import>();
     }
     std::vector<Import> result;
     result.reserve(d->imports.size());
     for (unsigned int i = 0 ; i < d->imports.size() ; ++i) {
         result.push_back(Import(d, i));
     }
     return result;
 }
 
 GpgME::Import::Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int i)
     : d(parent), idx(i)
 {
 
 }
 
 GpgME::Import::Import() : d(), idx(0) {}
 
 bool GpgME::Import::isNull() const
 {
     return !d || idx >= d->imports.size() ;
 }
 
 const char *GpgME::Import::fingerprint() const
 {
-    return isNull() ? 0 : d->imports[idx]->fpr ;
+    return isNull() ? nullptr : d->imports[idx]->fpr ;
 }
 
 GpgME::Error GpgME::Import::error() const
 {
     return Error(isNull() ? 0 : d->imports[idx]->result);
 }
 
 GpgME::Import::Status GpgME::Import::status() const
 {
     if (isNull()) {
         return Unknown;
     }
     const unsigned int s = d->imports[idx]->status;
     unsigned int result = Unknown;
     if (s & GPGME_IMPORT_NEW) {
         result |= NewKey;
     }
     if (s & GPGME_IMPORT_UID) {
         result |= NewUserIDs;
     }
     if (s & GPGME_IMPORT_SIG) {
         result |= NewSignatures;
     }
     if (s & GPGME_IMPORT_SUBKEY) {
         result |= NewSubkeys;
     }
     if (s & GPGME_IMPORT_SECRET) {
         result |= ContainedSecretKey;
     }
     return static_cast<Status>(result);
 }
diff --git a/lang/cpp/src/key.cpp b/lang/cpp/src/key.cpp
index 0d272926..4638fd86 100644
--- a/lang/cpp/src/key.cpp
+++ b/lang/cpp/src/key.cpp
@@ -1,1098 +1,1098 @@
 /*
   key.cpp - wraps a gpgme key
   Copyright (C) 2003, 2005 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <key.h>
 
 #include "util.h"
 #include "tofuinfo.h"
 #include "context.h"
 
 #include <gpgme.h>
 
 #include <string.h>
 #include <strings.h>
 #include <istream>
 #include <iterator>
 
 const GpgME::Key::Null GpgME::Key::null;
 
 namespace GpgME
 {
 
 Key::Key() : key() {}
 
 Key::Key(const Null &) : key() {}
 
 Key::Key(const shared_gpgme_key_t &k) : key(k) {}
 
 Key::Key(gpgme_key_t k, bool ref)
     : key(k
           ? shared_gpgme_key_t(k, &gpgme_key_unref)
           : shared_gpgme_key_t())
 {
     if (ref && impl()) {
         gpgme_key_ref(impl());
     }
 }
 
 UserID Key::userID(unsigned int index) const
 {
     return UserID(key, index);
 }
 
 Subkey Key::subkey(unsigned int index) const
 {
     return Subkey(key, index);
 }
 
 unsigned int Key::numUserIDs() const
 {
     if (!key) {
         return 0;
     }
     unsigned int count = 0;
     for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) {
         ++count;
     }
     return count;
 }
 
 unsigned int Key::numSubkeys() const
 {
     if (!key) {
         return 0;
     }
     unsigned int count = 0;
     for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) {
         ++count;
     }
     return count;
 }
 
 std::vector<UserID> Key::userIDs() const
 {
     if (!key) {
         return std::vector<UserID>();
     }
 
     std::vector<UserID> v;
     v.reserve(numUserIDs());
     for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) {
         v.push_back(UserID(key, uid));
     }
     return v;
 }
 
 std::vector<Subkey> Key::subkeys() const
 {
     if (!key) {
         return std::vector<Subkey>();
     }
 
     std::vector<Subkey> v;
     v.reserve(numSubkeys());
     for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) {
         v.push_back(Subkey(key, subkey));
     }
     return v;
 }
 
 Key::OwnerTrust Key::ownerTrust() const
 {
     if (!key) {
         return Unknown;
     }
     switch (key->owner_trust) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return Unknown;
     case GPGME_VALIDITY_UNDEFINED: return Undefined;
     case GPGME_VALIDITY_NEVER:     return Never;
     case GPGME_VALIDITY_MARGINAL:  return Marginal;
     case GPGME_VALIDITY_FULL:     return Full;
     case GPGME_VALIDITY_ULTIMATE: return Ultimate;
     }
 }
 char Key::ownerTrustAsString() const
 {
     if (!key) {
         return '?';
     }
     switch (key->owner_trust) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return '?';
     case GPGME_VALIDITY_UNDEFINED: return 'q';
     case GPGME_VALIDITY_NEVER:     return 'n';
     case GPGME_VALIDITY_MARGINAL:  return 'm';
     case GPGME_VALIDITY_FULL:     return 'f';
     case GPGME_VALIDITY_ULTIMATE: return 'u';
     }
 }
 
 Protocol Key::protocol() const
 {
     if (!key) {
         return UnknownProtocol;
     }
     switch (key->protocol) {
     case GPGME_PROTOCOL_CMS:     return CMS;
     case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
     default:                     return UnknownProtocol;
     }
 }
 
 const char *Key::protocolAsString() const
 {
-    return key ? gpgme_get_protocol_name(key->protocol) : 0 ;
+    return key ? gpgme_get_protocol_name(key->protocol) : nullptr ;
 }
 
 bool Key::isRevoked() const
 {
     return key && key->revoked;
 }
 
 bool Key::isExpired() const
 {
     return key && key->expired;
 }
 
 bool Key::isDisabled() const
 {
     return key && key->disabled;
 }
 
 bool Key::isInvalid() const
 {
     return key && key->invalid;
 }
 
 bool Key::hasSecret() const
 {
     return key && key->secret;
 }
 
 bool Key::isRoot() const
 {
     return key && key->subkeys && key->subkeys->fpr && key->chain_id &&
            strcasecmp(key->subkeys->fpr, key->chain_id) == 0;
 }
 
 bool Key::canEncrypt() const
 {
     return key && key->can_encrypt;
 }
 
 bool Key::canSign() const
 {
 #ifndef GPGME_CAN_SIGN_ON_SECRET_OPENPGP_KEYLISTING_NOT_BROKEN
     if (key && key->protocol == GPGME_PROTOCOL_OpenPGP) {
         return true;
     }
 #endif
     return canReallySign();
 }
 
 bool Key::canReallySign() const
 {
     return key && key->can_sign;
 }
 
 bool Key::canCertify() const
 {
     return key && key->can_certify;
 }
 
 bool Key::canAuthenticate() const
 {
     return key && key->can_authenticate;
 }
 
 bool Key::isQualified() const
 {
     return key && key->is_qualified;
 }
 
 bool Key::isDeVs() const
 {
     if (!key) {
         return false;
     }
     if (!key->subkeys || !key->subkeys->is_de_vs) {
         return false;
     }
     for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) {
         if (!subkey->is_de_vs) {
             return false;
         }
     }
     return true;
 }
 
 const char *Key::issuerSerial() const
 {
-    return key ? key->issuer_serial : 0 ;
+    return key ? key->issuer_serial : nullptr ;
 }
 const char *Key::issuerName() const
 {
-    return key ? key->issuer_name : 0 ;
+    return key ? key->issuer_name : nullptr ;
 }
 const char *Key::chainID() const
 {
-    return key ? key->chain_id : 0 ;
+    return key ? key->chain_id : nullptr ;
 }
 
 const char *Key::keyID() const
 {
-    return key && key->subkeys ? key->subkeys->keyid : 0 ;
+    return key && key->subkeys ? key->subkeys->keyid : nullptr ;
 }
 
 const char *Key::shortKeyID() const
 {
     if (!key || !key->subkeys || !key->subkeys->keyid) {
-        return 0;
+        return nullptr;
     }
     const int len = strlen(key->subkeys->keyid);
     if (len > 8) {
         return key->subkeys->keyid + len - 8; // return the last 8 bytes (in hex notation)
     } else {
         return key->subkeys->keyid;
     }
 }
 
 const char *Key::primaryFingerprint() const
 {
     if (!key) {
         return nullptr;
     }
     if (key->fpr) {
         /* Return what gpgme thinks is the primary fingerprint */
         return key->fpr;
     }
     if (key->subkeys) {
         /* Return the first subkeys fingerprint */
         return key->subkeys->fpr;
     }
     return nullptr;
 }
 
 unsigned int Key::keyListMode() const
 {
-    return key ? convert_from_gpgme_keylist_mode_t(key->keylist_mode) : 0 ;
+    return key ? convert_from_gpgme_keylist_mode_t(key->keylist_mode) : 0;
 }
 
 const Key &Key::mergeWith(const Key &other)
 {
     // ### incomplete. Just merges has* and can*, nothing else atm
     // ### detach also missing
 
     if (!this->primaryFingerprint() ||
             !other.primaryFingerprint() ||
             strcasecmp(this->primaryFingerprint(), other.primaryFingerprint()) != 0) {
         return *this; // only merge the Key object which describe the same key
     }
 
     const gpgme_key_t me = impl();
     const gpgme_key_t him = other.impl();
 
     if (!me || !him) {
         return *this;
     }
 
     me->revoked          |= him->revoked;
     me->expired          |= him->expired;
     me->disabled         |= him->disabled;
     me->invalid          |= him->invalid;
     me->can_encrypt      |= him->can_encrypt;
     me->can_sign         |= him->can_sign;
     me->can_certify      |= him->can_certify;
     me->secret           |= him->secret;
     me->can_authenticate |= him->can_authenticate;
     me->is_qualified     |= him->is_qualified;
     me->keylist_mode     |= him->keylist_mode;
 
     // make sure the gpgme_sub_key_t::is_cardkey flag isn't lost:
     for (gpgme_sub_key_t mysk = me->subkeys ; mysk ; mysk = mysk->next) {
         for (gpgme_sub_key_t hissk = him->subkeys ; hissk ; hissk = hissk->next) {
             if (strcmp(mysk->fpr, hissk->fpr) == 0) {
                 mysk->is_cardkey |= hissk->is_cardkey;
                 break;
             }
         }
     }
 
     return *this;
 }
 
 void Key::update()
 {
     if (isNull() || !primaryFingerprint()) {
         return;
     }
     auto ctx = Context::createForProtocol(protocol());
     if (!ctx) {
         return;
     }
     ctx->setKeyListMode(KeyListMode::Local |
                         KeyListMode::Signatures |
                         KeyListMode::SignatureNotations |
                         KeyListMode::Validate |
                         KeyListMode::WithTofu);
     Error err;
     auto newKey = ctx->key(primaryFingerprint(), err, true);
     // Not secret so we get the information from the pubring.
     if (newKey.isNull())
       {
         newKey = ctx->key(primaryFingerprint(), err, false);
       }
     delete ctx;
     if (err) {
         return;
     }
     swap(newKey);
     return;
 }
 
 // static
 Key Key::locate(const char *mbox)
 {
     if (!mbox) {
         return Key();
     }
 
     auto ctx = Context::createForProtocol(OpenPGP);
     if (!ctx) {
         return Key();
     }
 
     ctx->setKeyListMode (Extern | Local);
 
     Error e = ctx->startKeyListing (mbox);
     auto ret = ctx->nextKey (e);
     delete ctx;
 
     return ret;
 }
 
 //
 //
 // class Subkey
 //
 //
 
 gpgme_sub_key_t find_subkey(const shared_gpgme_key_t &key, unsigned int idx)
 {
     if (key) {
         for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next, --idx) {
             if (idx == 0) {
                 return s;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
 gpgme_sub_key_t verify_subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey)
 {
     if (key) {
         for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next) {
             if (s == subkey) {
                 return subkey;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
-Subkey::Subkey() : key(), subkey(0) {}
+Subkey::Subkey() : key(), subkey(nullptr) {}
 
 Subkey::Subkey(const shared_gpgme_key_t &k, unsigned int idx)
     : key(k), subkey(find_subkey(k, idx))
 {
 
 }
 
 Subkey::Subkey(const shared_gpgme_key_t &k, gpgme_sub_key_t sk)
     : key(k), subkey(verify_subkey(k, sk))
 {
 
 }
 
 Key Subkey::parent() const
 {
     return Key(key);
 }
 
 const char *Subkey::keyID() const
 {
-    return subkey ? subkey->keyid : 0 ;
+    return subkey ? subkey->keyid : nullptr ;
 }
 
 const char *Subkey::fingerprint() const
 {
-    return subkey ? subkey->fpr : 0 ;
+    return subkey ? subkey->fpr : nullptr ;
 }
 
 Subkey::PubkeyAlgo Subkey::publicKeyAlgorithm() const
 {
     return subkey ? static_cast<PubkeyAlgo>(subkey->pubkey_algo) : AlgoUnknown;
 }
 
 const char *Subkey::publicKeyAlgorithmAsString() const
 {
     return gpgme_pubkey_algo_name(subkey ? subkey->pubkey_algo : (gpgme_pubkey_algo_t)0);
 }
 
 /* static */
 const char *Subkey::publicKeyAlgorithmAsString(PubkeyAlgo algo)
 {
     if (algo == AlgoUnknown) {
         return NULL;
     }
     return gpgme_pubkey_algo_name(static_cast<gpgme_pubkey_algo_t>(algo));
 }
 
 std::string Subkey::algoName() const
 {
     char *gpgmeStr;
     if (subkey && (gpgmeStr = gpgme_pubkey_algo_string(subkey))) {
         std::string ret = std::string(gpgmeStr);
         gpgme_free(gpgmeStr);
         return ret;
     }
     return std::string();
 }
 
 bool Subkey::canEncrypt() const
 {
     return subkey && subkey->can_encrypt;
 }
 
 bool Subkey::canSign() const
 {
     return subkey && subkey->can_sign;
 }
 
 bool Subkey::canCertify() const
 {
     return subkey && subkey->can_certify;
 }
 
 bool Subkey::canAuthenticate() const
 {
     return subkey && subkey->can_authenticate;
 }
 
 bool Subkey::isQualified() const
 {
     return subkey && subkey->is_qualified;
 }
 
 bool Subkey::isDeVs() const
 {
     return subkey && subkey->is_de_vs;
 }
 
 bool Subkey::isCardKey() const
 {
     return subkey && subkey->is_cardkey;
 }
 
 const char *Subkey::cardSerialNumber() const
 {
     return subkey ? subkey->card_number : nullptr;
 }
 
 const char *Subkey::keyGrip() const
 {
     return subkey ? subkey->keygrip : nullptr;
 }
 
 bool Subkey::isSecret() const
 {
     return subkey && subkey->secret;
 }
 
 unsigned int Subkey::length() const
 {
     return subkey ? subkey->length : 0 ;
 }
 
 time_t Subkey::creationTime() const
 {
     return static_cast<time_t>(subkey ? subkey->timestamp : 0);
 }
 
 time_t Subkey::expirationTime() const
 {
     return static_cast<time_t>(subkey ? subkey->expires : 0);
 }
 
 bool Subkey::neverExpires() const
 {
     return expirationTime() == time_t(0);
 }
 
 bool Subkey::isRevoked() const
 {
     return subkey && subkey->revoked;
 }
 
 bool Subkey::isInvalid() const
 {
     return subkey && subkey->invalid;
 }
 
 bool Subkey::isExpired() const
 {
     return subkey && subkey->expired;
 }
 
 bool Subkey::isDisabled() const
 {
     return subkey && subkey->disabled;
 }
 
 //
 //
 // class UserID
 //
 //
 
 gpgme_user_id_t find_uid(const shared_gpgme_key_t &key, unsigned int idx)
 {
     if (key) {
         for (gpgme_user_id_t u = key->uids ; u ; u = u->next, --idx) {
             if (idx == 0) {
                 return u;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
 gpgme_user_id_t verify_uid(const shared_gpgme_key_t &key, gpgme_user_id_t uid)
 {
     if (key) {
         for (gpgme_user_id_t u = key->uids ; u ; u = u->next) {
             if (u == uid) {
                 return uid;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
-UserID::UserID() : key(), uid(0) {}
+UserID::UserID() : key(), uid(nullptr) {}
 
 UserID::UserID(const shared_gpgme_key_t &k, gpgme_user_id_t u)
     : key(k), uid(verify_uid(k, u))
 {
 
 }
 
 UserID::UserID(const shared_gpgme_key_t &k, unsigned int idx)
     : key(k), uid(find_uid(k, idx))
 {
 
 }
 
 Key UserID::parent() const
 {
     return Key(key);
 }
 
 UserID::Signature UserID::signature(unsigned int index) const
 {
     return Signature(key, uid, index);
 }
 
 unsigned int UserID::numSignatures() const
 {
     if (!uid) {
         return 0;
     }
     unsigned int count = 0;
     for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) {
         ++count;
     }
     return count;
 }
 
 std::vector<UserID::Signature> UserID::signatures() const
 {
     if (!uid) {
         return std::vector<Signature>();
     }
 
     std::vector<Signature> v;
     v.reserve(numSignatures());
     for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) {
         v.push_back(Signature(key, uid, sig));
     }
     return v;
 }
 
 const char *UserID::id() const
 {
-    return uid ? uid->uid : 0 ;
+    return uid ? uid->uid : nullptr ;
 }
 
 const char *UserID::name() const
 {
-    return uid ? uid->name : 0 ;
+    return uid ? uid->name : nullptr ;
 }
 
 const char *UserID::email() const
 {
-    return uid ? uid->email : 0 ;
+    return uid ? uid->email : nullptr ;
 }
 
 const char *UserID::comment() const
 {
-    return uid ? uid->comment : 0 ;
+    return uid ? uid->comment : nullptr ;
 }
 
 UserID::Validity UserID::validity() const
 {
     if (!uid) {
         return Unknown;
     }
     switch (uid->validity) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return Unknown;
     case GPGME_VALIDITY_UNDEFINED: return Undefined;
     case GPGME_VALIDITY_NEVER:     return Never;
     case GPGME_VALIDITY_MARGINAL:  return Marginal;
     case GPGME_VALIDITY_FULL:      return Full;
     case GPGME_VALIDITY_ULTIMATE:  return Ultimate;
     }
 }
 
 char UserID::validityAsString() const
 {
     if (!uid) {
         return '?';
     }
     switch (uid->validity) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return '?';
     case GPGME_VALIDITY_UNDEFINED: return 'q';
     case GPGME_VALIDITY_NEVER:     return 'n';
     case GPGME_VALIDITY_MARGINAL:  return 'm';
     case GPGME_VALIDITY_FULL:      return 'f';
     case GPGME_VALIDITY_ULTIMATE:  return 'u';
     }
 }
 
 bool UserID::isRevoked() const
 {
     return uid && uid->revoked;
 }
 
 bool UserID::isInvalid() const
 {
     return uid && uid->invalid;
 }
 
 TofuInfo UserID::tofuInfo() const
 {
     if (!uid) {
         return TofuInfo();
     }
     return TofuInfo(uid->tofu);
 }
 
 //
 //
 // class Signature
 //
 //
 
 gpgme_key_sig_t find_signature(gpgme_user_id_t uid, unsigned int idx)
 {
     if (uid) {
         for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next, --idx) {
             if (idx == 0) {
                 return s;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
 gpgme_key_sig_t verify_signature(gpgme_user_id_t uid, gpgme_key_sig_t sig)
 {
     if (uid) {
         for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next) {
             if (s == sig) {
                 return sig;
             }
         }
     }
-    return 0;
+    return nullptr;
 }
 
-UserID::Signature::Signature() : key(), uid(0), sig(0) {}
+UserID::Signature::Signature() : key(), uid(nullptr), sig(nullptr) {}
 
 UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, unsigned int idx)
     : key(k), uid(verify_uid(k, u)), sig(find_signature(uid, idx))
 {
 
 }
 
 UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, gpgme_key_sig_t s)
     : key(k), uid(verify_uid(k, u)), sig(verify_signature(uid, s))
 {
 
 }
 
 UserID UserID::Signature::parent() const
 {
     return UserID(key, uid);
 }
 
 const char *UserID::Signature::signerKeyID() const
 {
-    return sig ? sig->keyid : 0 ;
+    return sig ? sig->keyid : nullptr ;
 }
 
 const char *UserID::Signature::algorithmAsString() const
 {
     return gpgme_pubkey_algo_name(sig ? sig->pubkey_algo : (gpgme_pubkey_algo_t)0);
 }
 
 unsigned int UserID::Signature::algorithm() const
 {
     return sig ? sig->pubkey_algo : 0 ;
 }
 
 time_t UserID::Signature::creationTime() const
 {
     return static_cast<time_t>(sig ? sig->timestamp : 0);
 }
 
 time_t UserID::Signature::expirationTime() const
 {
     return static_cast<time_t>(sig ? sig->expires : 0);
 }
 
 bool UserID::Signature::neverExpires() const
 {
     return expirationTime() == time_t(0);
 }
 
 bool UserID::Signature::isRevokation() const
 {
     return sig && sig->revoked;
 }
 
 bool UserID::Signature::isInvalid() const
 {
     return sig && sig->invalid;
 }
 
 bool UserID::Signature::isExpired() const
 {
     return sig && sig->expired;
 }
 
 bool UserID::Signature::isExportable() const
 {
     return sig && sig->exportable;
 }
 
 const char *UserID::Signature::signerUserID() const
 {
-    return sig ? sig->uid : 0 ;
+    return sig ? sig->uid : nullptr ;
 }
 
 const char *UserID::Signature::signerName() const
 {
-    return sig ? sig->name : 0 ;
+    return sig ? sig->name : nullptr ;
 }
 
 const char *UserID::Signature::signerEmail() const
 {
-    return sig ? sig->email : 0 ;
+    return sig ? sig->email : nullptr ;
 }
 
 const char *UserID::Signature::signerComment() const
 {
-    return sig ? sig->comment : 0 ;
+    return sig ? sig->comment : nullptr ;
 }
 
 unsigned int UserID::Signature::certClass() const
 {
     return sig ? sig->sig_class : 0 ;
 }
 
 UserID::Signature::Status UserID::Signature::status() const
 {
     if (!sig) {
         return GeneralError;
     }
 
     switch (gpgme_err_code(sig->status)) {
     case GPG_ERR_NO_ERROR:      return NoError;
     case GPG_ERR_SIG_EXPIRED:   return SigExpired;
     case GPG_ERR_KEY_EXPIRED:   return KeyExpired;
     case GPG_ERR_BAD_SIGNATURE: return BadSignature;
     case GPG_ERR_NO_PUBKEY:     return NoPublicKey;
     default:
     case GPG_ERR_GENERAL:       return GeneralError;
     }
 }
 
 std::string UserID::Signature::statusAsString() const
 {
     if (!sig) {
         return std::string();
     }
     char buf[ 1024 ];
     gpgme_strerror_r(sig->status, buf, sizeof buf);
     buf[ sizeof buf - 1 ] = '\0';
     return std::string(buf);
 }
 
 GpgME::Notation UserID::Signature::notation(unsigned int idx) const
 {
     if (!sig) {
         return GpgME::Notation();
     }
     for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
         if (nota->name) {
             if (idx-- == 0) {
                 return GpgME::Notation(nota);
             }
         }
     }
     return GpgME::Notation();
 }
 
 unsigned int UserID::Signature::numNotations() const
 {
     if (!sig) {
         return 0;
     }
     unsigned int count = 0;
     for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
         if (nota->name) {
             ++count; // others are policy URLs...
         }
     }
     return count;
 }
 
 std::vector<Notation> UserID::Signature::notations() const
 {
     if (!sig) {
         return std::vector<GpgME::Notation>();
     }
     std::vector<GpgME::Notation> v;
     v.reserve(numNotations());
     for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
         if (nota->name) {
             v.push_back(GpgME::Notation(nota));
         }
     }
     return v;
 }
 
 const char *UserID::Signature::policyURL() const
 {
     if (!sig) {
-        return 0;
+        return nullptr;
     }
     for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
         if (!nota->name) {
             return nota->value;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 std::string UserID::addrSpecFromString(const char *userid)
 {
     if (!userid) {
         return std::string();
     }
     char *normalized = gpgme_addrspec_from_uid (userid);
     if (normalized) {
         std::string ret(normalized);
         gpgme_free(normalized);
         return ret;
     }
     return std::string();
 }
 
 std::string UserID::addrSpec() const
 {
     if (!uid || !uid->address) {
         return std::string();
     }
 
     return uid->address;
 }
 
 Error UserID::revoke()
 {
     if (isNull()) {
         return Error::fromCode(GPG_ERR_GENERAL);
     }
     auto ctx = Context::createForProtocol(parent().protocol());
     if (!ctx) {
         return Error::fromCode(GPG_ERR_INV_ENGINE);
     }
     Error ret = ctx->revUid(key, id());
     delete ctx;
     return ret;
 }
 
 static Key::Origin gpgme_origin_to_pp_origin (const unsigned int origin)
 {
     switch (origin) {
         case GPGME_KEYORG_KS:
             return Key::OriginKS;
         case GPGME_KEYORG_DANE:
             return Key::OriginDane;
         case GPGME_KEYORG_WKD:
             return Key::OriginWKD;
         case GPGME_KEYORG_URL:
             return Key::OriginURL;
         case GPGME_KEYORG_FILE:
             return Key::OriginFile;
         case GPGME_KEYORG_SELF:
             return Key::OriginSelf;
         case GPGME_KEYORG_OTHER:
             return Key::OriginOther;
         case GPGME_KEYORG_UNKNOWN:
         default:
             return Key::OriginUnknown;
     }
 }
 
 Key::Origin UserID::origin() const
 {
     if (isNull()) {
         return Key::OriginUnknown;
     }
     return gpgme_origin_to_pp_origin(uid->origin);
 }
 
 time_t UserID::lastUpdate() const
 {
     return static_cast<time_t>(uid ? uid->last_update : 0);
 }
 
 Error Key::addUid(const char *uid)
 {
     if (isNull()) {
         return Error::fromCode(GPG_ERR_GENERAL);
     }
     auto ctx = Context::createForProtocol(protocol());
     if (!ctx) {
         return Error::fromCode(GPG_ERR_INV_ENGINE);
     }
     Error ret = ctx->addUid(key, uid);
     delete ctx;
     return ret;
 }
 
 Key::Origin Key::origin() const
 {
     if (isNull()) {
         return OriginUnknown;
     }
     return gpgme_origin_to_pp_origin(key->origin);
 }
 
 time_t Key::lastUpdate() const
 {
     return static_cast<time_t>(key ? key->last_update : 0);
 }
 
 bool Key::isBad() const
 {
     return isNull() || isRevoked() || isExpired() || isDisabled() || isInvalid();
 }
 
 bool Subkey::isBad() const
 {
     return isNull() || isRevoked() || isExpired() || isDisabled() || isInvalid();
 }
 
 bool UserID::isBad() const
 {
     return isNull() || isRevoked() || isInvalid();
 }
 
 bool UserID::Signature::isBad() const
 {
     return isNull() || isExpired() || isInvalid();
 }
 
 std::ostream &operator<<(std::ostream &os, const UserID &uid)
 {
     os << "GpgME::UserID(";
     if (!uid.isNull()) {
         os << "\n name:      " << protect(uid.name())
            << "\n email:     " << protect(uid.email())
            << "\n mbox:      " << uid.addrSpec()
            << "\n comment:   " << protect(uid.comment())
            << "\n validity:  " << uid.validityAsString()
            << "\n revoked:   " << uid.isRevoked()
            << "\n invalid:   " << uid.isInvalid()
            << "\n numsigs:   " << uid.numSignatures()
            << "\n origin:    " << uid.origin()
            << "\n updated:   " << uid.lastUpdate()
            << "\n tofuinfo:\n" << uid.tofuInfo();
     }
     return os << ')';
 }
 
 std::ostream &operator<<(std::ostream &os, const Key &key)
 {
     os << "GpgME::Key(";
     if (!key.isNull()) {
         os << "\n protocol:   " << protect(key.protocolAsString())
            << "\n ownertrust: " << key.ownerTrustAsString()
            << "\n issuer:     " << protect(key.issuerName())
            << "\n fingerprint:" << protect(key.primaryFingerprint())
            << "\n listmode:   " << key.keyListMode()
            << "\n canSign:    " << key.canReallySign()
            << "\n canEncrypt: " << key.canEncrypt()
            << "\n canCertify: " << key.canCertify()
            << "\n canAuth:    " << key.canAuthenticate()
            << "\n origin:     " << key.origin()
            << "\n updated:    " << key.lastUpdate()
            << "\n uids:\n";
         const std::vector<UserID> uids = key.userIDs();
         std::copy(uids.begin(), uids.end(),
                   std::ostream_iterator<UserID>(os, "\n"));
     }
     return os << ')';
 }
 
 } // namespace GpgME
diff --git a/lang/cpp/src/keygenerationresult.cpp b/lang/cpp/src/keygenerationresult.cpp
index ebbb3b99..49342f42 100644
--- a/lang/cpp/src/keygenerationresult.cpp
+++ b/lang/cpp/src/keygenerationresult.cpp
@@ -1,98 +1,98 @@
 /*
   keygenerationresult.cpp - wraps a gpgme keygen result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <keygenerationresult.h>
 #include "result_p.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 #include <cstdlib>
 
 #include <string.h>
 
 class GpgME::KeyGenerationResult::Private
 {
 public:
     Private(const _gpgme_op_genkey_result &r) : res(r)
     {
         if (res.fpr) {
             res.fpr = strdup(res.fpr);
         }
     }
     ~Private()
     {
         if (res.fpr) {
             std::free(res.fpr);
         }
-        res.fpr = 0;
+        res.fpr = nullptr;
     }
 
     _gpgme_op_genkey_result res;
 };
 
 GpgME::KeyGenerationResult::KeyGenerationResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::KeyGenerationResult::KeyGenerationResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::KeyGenerationResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_genkey_result_t res = gpgme_op_genkey_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(*res));
 }
 
 make_standard_stuff(KeyGenerationResult)
 
 bool GpgME::KeyGenerationResult::isPrimaryKeyGenerated() const
 {
     return d && d->res.primary;
 }
 
 bool GpgME::KeyGenerationResult::isSubkeyGenerated() const
 {
     return d && d->res.sub;
 }
 
 const char *GpgME::KeyGenerationResult::fingerprint() const
 {
-    return d ? d->res.fpr : 0 ;
+    return d ? d->res.fpr : nullptr ;
 }
diff --git a/lang/cpp/src/scdgetinfoassuantransaction.h b/lang/cpp/src/scdgetinfoassuantransaction.h
index ef805303..621725e4 100644
--- a/lang/cpp/src/scdgetinfoassuantransaction.h
+++ b/lang/cpp/src/scdgetinfoassuantransaction.h
@@ -1,78 +1,78 @@
 /*
   scdgetinfoassuantransaction.h - Assuan Transaction to get information from scdaemon
   Copyright (C) 2009 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__
 #define __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__
 
 #include <interfaces/assuantransaction.h>
 
 #include <string>
 #include <vector>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT ScdGetInfoAssuanTransaction : public AssuanTransaction
 {
 public:
     enum InfoItem {
         Version,         // string
         Pid,             // unsigned long
         SocketName,      // string (path)
         Status,          // char (status)
         ReaderList,      // string list
         DenyAdmin,       // (none, returns GPG_ERR_GENERAL when admin commands are allowed)
         ApplicationList, // string list
 
         LastInfoItem
     };
 
     explicit ScdGetInfoAssuanTransaction(InfoItem item);
     ~ScdGetInfoAssuanTransaction();
 
     std::string version() const;
     unsigned int pid() const;
     std::string socketName() const;
     char status() const;
     std::vector<std::string> readerList() const;
     std::vector<std::string> applicationList() const;
 
 private:
-    /* reimp */ const char *command() const;
-    /* reimp */ Error data(const char *data, size_t datalen);
-    /* reimp */ Data inquire(const char *name, const char *args, Error &err);
-    /* reimp */ Error status(const char *status, const char *args);
+    const char *command() const;
+    Error data(const char *data, size_t datalen) override;
+    Data inquire(const char *name, const char *args, Error &err) override;
+    Error status(const char *status, const char *args) override;
 
 private:
     void makeCommand() const;
 
 private:
     InfoItem m_item;
     mutable std::string m_command;
     std::string m_data;
 };
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__
diff --git a/lang/cpp/src/signingresult.cpp b/lang/cpp/src/signingresult.cpp
index 6a5231ff..6e0dd90a 100644
--- a/lang/cpp/src/signingresult.cpp
+++ b/lang/cpp/src/signingresult.cpp
@@ -1,271 +1,271 @@
 /*
   signingresult.cpp - wraps a gpgme verify result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <signingresult.h>
 #include "result_p.h"
 #include "util.h"
 
 #include <gpgme.h>
 
 #include <cstring>
 #include <cstdlib>
 #include <algorithm>
 #include <istream>
 #include <iterator>
 
 #include <string.h>
 
 class GpgME::SigningResult::Private
 {
 public:
     Private(const gpgme_sign_result_t r)
     {
         if (!r) {
             return;
         }
         for (gpgme_new_signature_t is = r->signatures ; is ; is = is->next) {
             gpgme_new_signature_t copy = new _gpgme_new_signature(*is);
             if (is->fpr) {
                 copy->fpr = strdup(is->fpr);
             }
-            copy->next = 0;
+            copy->next = nullptr;
             created.push_back(copy);
         }
         for (gpgme_invalid_key_t ik = r->invalid_signers ; ik ; ik = ik->next) {
             gpgme_invalid_key_t copy = new _gpgme_invalid_key(*ik);
             if (ik->fpr) {
                 copy->fpr = strdup(ik->fpr);
             }
-            copy->next = 0;
+            copy->next = nullptr;
             invalid.push_back(copy);
         }
     }
     ~Private()
     {
         for (std::vector<gpgme_new_signature_t>::iterator it = created.begin() ; it != created.end() ; ++it) {
             std::free((*it)->fpr);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
         }
         for (std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it) {
             std::free((*it)->fpr);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
         }
     }
 
     std::vector<gpgme_new_signature_t> created;
     std::vector<gpgme_invalid_key_t> invalid;
 };
 
 GpgME::SigningResult::SigningResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::SigningResult::SigningResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::SigningResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_sign_result_t res = gpgme_op_sign_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(res));
 }
 
 make_standard_stuff(SigningResult)
 
 GpgME::CreatedSignature GpgME::SigningResult::createdSignature(unsigned int idx) const
 {
     return CreatedSignature(d, idx);
 }
 
 std::vector<GpgME::CreatedSignature> GpgME::SigningResult::createdSignatures() const
 {
     if (!d) {
         return std::vector<CreatedSignature>();
     }
     std::vector<CreatedSignature> result;
     result.reserve(d->created.size());
     for (unsigned int i = 0 ; i < d->created.size() ; ++i) {
         result.push_back(CreatedSignature(d, i));
     }
     return result;
 }
 
 GpgME::InvalidSigningKey GpgME::SigningResult::invalidSigningKey(unsigned int idx) const
 {
     return InvalidSigningKey(d, idx);
 }
 
 std::vector<GpgME::InvalidSigningKey> GpgME::SigningResult::invalidSigningKeys() const
 {
     if (!d) {
         return std::vector<GpgME::InvalidSigningKey>();
     }
     std::vector<GpgME::InvalidSigningKey> result;
     result.reserve(d->invalid.size());
     for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) {
         result.push_back(InvalidSigningKey(d, i));
     }
     return result;
 }
 
 GpgME::InvalidSigningKey::InvalidSigningKey(const std::shared_ptr<SigningResult::Private> &parent, unsigned int i)
     : d(parent), idx(i)
 {
 
 }
 
 GpgME::InvalidSigningKey::InvalidSigningKey() : d(), idx(0) {}
 
 bool GpgME::InvalidSigningKey::isNull() const
 {
     return !d || idx >= d->invalid.size() ;
 }
 
 const char *GpgME::InvalidSigningKey::fingerprint() const
 {
-    return isNull() ? 0 : d->invalid[idx]->fpr ;
+    return isNull() ? nullptr : d->invalid[idx]->fpr ;
 }
 
 GpgME::Error GpgME::InvalidSigningKey::reason() const
 {
     return Error(isNull() ? 0 : d->invalid[idx]->reason);
 }
 
 GpgME::CreatedSignature::CreatedSignature(const std::shared_ptr<SigningResult::Private> &parent, unsigned int i)
     : d(parent), idx(i)
 {
 
 }
 
 GpgME::CreatedSignature::CreatedSignature() : d(), idx(0) {}
 
 bool GpgME::CreatedSignature::isNull() const
 {
     return !d || idx >= d->created.size() ;
 }
 
 const char *GpgME::CreatedSignature::fingerprint() const
 {
-    return isNull() ? 0 : d->created[idx]->fpr ;
+    return isNull() ? nullptr : d->created[idx]->fpr ;
 }
 
 time_t GpgME::CreatedSignature::creationTime() const
 {
     return static_cast<time_t>(isNull() ? 0 : d->created[idx]->timestamp);
 }
 
 GpgME::SignatureMode GpgME::CreatedSignature::mode() const
 {
     if (isNull()) {
         return NormalSignatureMode;
     }
     switch (d->created[idx]->type) {
     default:
     case GPGME_SIG_MODE_NORMAL: return NormalSignatureMode;
     case GPGME_SIG_MODE_DETACH: return Detached;
     case GPGME_SIG_MODE_CLEAR:  return Clearsigned;
     }
 }
 
 unsigned int GpgME::CreatedSignature::publicKeyAlgorithm() const
 {
     return isNull() ? 0 : d->created[idx]->pubkey_algo ;
 }
 
 const char *GpgME::CreatedSignature::publicKeyAlgorithmAsString() const
 {
     return gpgme_pubkey_algo_name(isNull() ? (gpgme_pubkey_algo_t)0 : d->created[idx]->pubkey_algo);
 }
 
 unsigned int GpgME::CreatedSignature::hashAlgorithm() const
 {
     return isNull() ? 0 : d->created[idx]->hash_algo ;
 }
 
 const char *GpgME::CreatedSignature::hashAlgorithmAsString() const
 {
     return gpgme_hash_algo_name(isNull() ? (gpgme_hash_algo_t)0 : d->created[idx]->hash_algo);
 }
 
 unsigned int GpgME::CreatedSignature::signatureClass() const
 {
     return isNull() ? 0 : d->created[idx]->sig_class ;
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const SigningResult &result)
 {
     os << "GpgME::SigningResult(";
     if (!result.isNull()) {
         os << "\n error:              " << result.error()
            << "\n createdSignatures:\n";
         const std::vector<CreatedSignature> cs = result.createdSignatures();
         std::copy(cs.begin(), cs.end(),
                   std::ostream_iterator<CreatedSignature>(os, "\n"));
         os << " invalidSigningKeys:\n";
         const std::vector<InvalidSigningKey> isk = result.invalidSigningKeys();
         std::copy(isk.begin(), isk.end(),
                   std::ostream_iterator<InvalidSigningKey>(os, "\n"));
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const CreatedSignature &sig)
 {
     os << "GpgME::CreatedSignature(";
     if (!sig.isNull()) {
         os << "\n fingerprint:        " << protect(sig.fingerprint())
            << "\n creationTime:       " << sig.creationTime()
            << "\n mode:               " << sig.mode()
            << "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString())
            << "\n hashAlgorithm:      " << protect(sig.hashAlgorithmAsString())
            << "\n signatureClass:     " << sig.signatureClass()
            << '\n';
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const InvalidSigningKey &key)
 {
     os << "GpgME::InvalidSigningKey(";
     if (!key.isNull()) {
         os << "\n fingerprint: " << protect(key.fingerprint())
            << "\n reason:      " << key.reason()
            << '\n';
     }
     return os << ')';
 }
diff --git a/lang/cpp/src/trustitem.cpp b/lang/cpp/src/trustitem.cpp
index c29c0f41..4302f657 100644
--- a/lang/cpp/src/trustitem.cpp
+++ b/lang/cpp/src/trustitem.cpp
@@ -1,120 +1,120 @@
 /*
   trustitem.cpp - wraps a gpgme trust item
   Copyright (C) 2003 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <trustitem.h>
 
 #include <gpgme.h>
 
 #include <cassert>
 
 namespace GpgME
 {
 
 class TrustItem::Private
 {
 public:
     Private(gpgme_trust_item_t aItem)
         : item(aItem)
     {
     }
 
     gpgme_trust_item_t item;
 };
 
 TrustItem::TrustItem(gpgme_trust_item_t item)
 {
     d = new Private(item);
     if (d->item) {
         gpgme_trust_item_ref(d->item);
     }
 }
 
 TrustItem::TrustItem(const TrustItem &other)
 {
     d = new Private(other.d->item);
     if (d->item) {
         gpgme_trust_item_ref(d->item);
     }
 }
 
 TrustItem::~TrustItem()
 {
     if (d->item) {
         gpgme_trust_item_unref(d->item);
     }
-    delete d; d = 0;
+    delete d; d = nullptr;
 }
 
 bool TrustItem::isNull() const
 {
     return !d || !d->item;
 }
 
 gpgme_trust_item_t TrustItem::impl() const
 {
     return d->item;
 }
 
 const char *TrustItem::keyID() const
 {
-    return d->item ? d->item->keyid : 0 ;
+    return d->item ? d->item->keyid : nullptr ;
 }
 
 const char *TrustItem::userID() const
 {
-    return d->item ? d->item->name : 0 ;
+    return d->item ? d->item->name : nullptr ;
 }
 
 const char *TrustItem::ownerTrustAsString() const
 {
-    return d->item ? d->item->owner_trust : 0 ;
+    return d->item ? d->item->owner_trust : nullptr ;
 }
 
 const char *TrustItem::validityAsString() const
 {
-    return d->item ? d->item->validity : 0 ;
+    return d->item ? d->item->validity : nullptr ;
 }
 
 int TrustItem::trustLevel() const
 {
     return d->item ? d->item->level : 0 ;
 }
 
 TrustItem::Type TrustItem::type() const
 {
     if (!d->item) {
         return Unknown;
     } else {
         return
             d->item->type == 1 ? Key :
             d->item->type == 2 ? UserID :
             Unknown ;
     }
 }
 
 } // namespace GpgME
diff --git a/lang/cpp/src/trustitem.h b/lang/cpp/src/trustitem.h
index ad2a4a61..d31dc0b7 100644
--- a/lang/cpp/src/trustitem.h
+++ b/lang/cpp/src/trustitem.h
@@ -1,83 +1,83 @@
 /*
   trustitem.h - wraps a gpgme trust item
   Copyright (C) 2003 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_TRUSTITEM_H__
 #define __GPGMEPP_TRUSTITEM_H__
 
 #include "gpgmefw.h"
 #include <key.h>
 #include "gpgmepp_export.h"
 
 #include <algorithm>
 
 namespace GpgME
 {
 
 class Context;
 
 class GPGMEPP_EXPORT TrustItem
 {
     friend class ::GpgME::Context;
 public:
-    explicit TrustItem(gpgme_trust_item_t item = 0);
+    explicit TrustItem(gpgme_trust_item_t item = nullptr);
     TrustItem(const TrustItem &other);
     virtual ~TrustItem();
 
     const TrustItem &operator=(TrustItem other)
     {
         swap(other);
         return *this;
     }
 
     void swap(TrustItem &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     const char *keyID() const;
     const char *userID() const;
 
     const char *ownerTrustAsString() const;
     const char *validityAsString() const;
 
     int trustLevel() const;
 
     enum Type { Unknown = 0, Key = 1, UserID = 2 };
     Type type() const;
 
 private:
     gpgme_trust_item_t impl() const;
     class Private;
     Private *d;
 };
 
 } // namepace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(TrustItem)
 
 #endif // __GPGMEPP_TRUSTITEM_H__
diff --git a/lang/cpp/src/verificationresult.cpp b/lang/cpp/src/verificationresult.cpp
index fa8237ad..1e9f81f5 100644
--- a/lang/cpp/src/verificationresult.cpp
+++ b/lang/cpp/src/verificationresult.cpp
@@ -1,622 +1,622 @@
 /*
   verificationresult.cpp - wraps a gpgme verify result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <verificationresult.h>
 #include <notation.h>
 #include "result_p.h"
 #include "util.h"
 #include "key.h"
 #include "context.h"
 
 #include <gpgme.h>
 
 #include <istream>
 #include <algorithm>
 #include <iterator>
 #include <string>
 #include <cstring>
 #include <cstdlib>
 
 #include <string.h>
 
 class GpgME::VerificationResult::Private
 {
 public:
     explicit Private(const gpgme_verify_result_t r)
     {
         if (!r) {
             return;
         }
         if (r->file_name) {
             file_name = r->file_name;
         }
         // copy recursively, using compiler-generated copy ctor.
         // We just need to handle the pointers in the structs:
         for (gpgme_signature_t is = r->signatures ; is ; is = is->next) {
             gpgme_signature_t scopy = new _gpgme_signature(*is);
             if (is->fpr) {
                 scopy->fpr = strdup(is->fpr);
             }
 // PENDING(marc) why does this crash on Windows in strdup()?
 # ifndef _WIN32
             if (is->pka_address) {
                 scopy->pka_address = strdup(is->pka_address);
             }
 # else
-            scopy->pka_address = 0;
+            scopy->pka_address = nullptr;
 # endif
-            scopy->next = 0;
+            scopy->next = nullptr;
             sigs.push_back(scopy);
             // copy keys
             if (scopy->key) {
                 keys.push_back(Key(scopy->key, true));
             } else {
                 keys.push_back(Key());
             }
             // copy notations:
             nota.push_back(std::vector<Nota>());
-            purls.push_back(0);
+            purls.push_back(nullptr);
             for (gpgme_sig_notation_t in = is->notations ; in ; in = in->next) {
                 if (!in->name) {
                     if (in->value) {
                         purls.back() = strdup(in->value);   // policy url
                     }
                     continue;
                 }
-                Nota n = { 0, 0, in->flags };
+                Nota n = { nullptr, nullptr, in->flags };
                 n.name = strdup(in->name);
                 if (in->value) {
                     n.value = strdup(in->value);
                 }
                 nota.back().push_back(n);
             }
         }
     }
     ~Private()
     {
         for (std::vector<gpgme_signature_t>::iterator it = sigs.begin() ; it != sigs.end() ; ++it) {
             std::free((*it)->fpr);
             std::free((*it)->pka_address);
-            delete *it; *it = 0;
+            delete *it; *it = nullptr;
         }
         for (std::vector< std::vector<Nota> >::iterator it = nota.begin() ; it != nota.end() ; ++it) {
             for (std::vector<Nota>::iterator jt = it->begin() ; jt != it->end() ; ++jt) {
-                std::free(jt->name);  jt->name = 0;
-                std::free(jt->value); jt->value = 0;
+                std::free(jt->name);  jt->name = nullptr;
+                std::free(jt->value); jt->value = nullptr;
             }
         }
         std::for_each(purls.begin(), purls.end(), &std::free);
     }
 
     struct Nota {
         char *name;
         char *value;
         gpgme_sig_notation_flags_t flags;
     };
 
     std::vector<gpgme_signature_t> sigs;
     std::vector< std::vector<Nota> > nota;
     std::vector<GpgME::Key> keys;
     std::vector<char *> purls;
     std::string file_name;
     Protocol proto;
 };
 
 GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, int error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, const Error &error)
     : GpgME::Result(error), d()
 {
     init(ctx);
 }
 
 void GpgME::VerificationResult::init(gpgme_ctx_t ctx)
 {
     if (!ctx) {
         return;
     }
     gpgme_verify_result_t res = gpgme_op_verify_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(res));
     gpgme_protocol_t proto = gpgme_get_protocol(ctx);
     d->proto = proto == GPGME_PROTOCOL_OpenPGP ? OpenPGP :
                proto == GPGME_PROTOCOL_CMS ? CMS :
                UnknownProtocol;
 }
 
 make_standard_stuff(VerificationResult)
 
 const char *GpgME::VerificationResult::fileName() const
 {
-    return d ? d->file_name.c_str() : 0 ;
+    return d ? d->file_name.c_str() : nullptr ;
 }
 
 unsigned int GpgME::VerificationResult::numSignatures() const
 {
     return d ? d->sigs.size() : 0 ;
 }
 
 GpgME::Signature GpgME::VerificationResult::signature(unsigned int idx) const
 {
     return Signature(d, idx);
 }
 
 std::vector<GpgME::Signature> GpgME::VerificationResult::signatures() const
 {
     if (!d) {
         return std::vector<Signature>();
     }
     std::vector<Signature> result;
     result.reserve(d->sigs.size());
     for (unsigned int i = 0 ; i < d->sigs.size() ; ++i) {
         result.push_back(Signature(d, i));
     }
     return result;
 }
 
 GpgME::Signature::Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int i)
     : d(parent), idx(i)
 {
 }
 
 GpgME::Signature::Signature() : d(), idx(0) {}
 
 bool GpgME::Signature::isNull() const
 {
     return !d || idx >= d->sigs.size() ;
 }
 
 GpgME::Signature::Summary GpgME::Signature::summary() const
 {
     if (isNull()) {
         return None;
     }
     gpgme_sigsum_t sigsum = d->sigs[idx]->summary;
     unsigned int result = 0;
     if (sigsum & GPGME_SIGSUM_VALID) {
         result |= Valid;
     }
     if (sigsum & GPGME_SIGSUM_GREEN) {
         result |= Green;
     }
     if (sigsum & GPGME_SIGSUM_RED) {
         result |= Red;
     }
     if (sigsum & GPGME_SIGSUM_KEY_REVOKED) {
         result |= KeyRevoked;
     }
     if (sigsum & GPGME_SIGSUM_KEY_EXPIRED) {
         result |= KeyExpired;
     }
     if (sigsum & GPGME_SIGSUM_SIG_EXPIRED) {
         result |= SigExpired;
     }
     if (sigsum & GPGME_SIGSUM_KEY_MISSING) {
         result |= KeyMissing;
     }
     if (sigsum & GPGME_SIGSUM_CRL_MISSING) {
         result |= CrlMissing;
     }
     if (sigsum & GPGME_SIGSUM_CRL_TOO_OLD) {
         result |= CrlTooOld;
     }
     if (sigsum & GPGME_SIGSUM_BAD_POLICY) {
         result |= BadPolicy;
     }
     if (sigsum & GPGME_SIGSUM_SYS_ERROR) {
         result |= SysError;
     }
     if (sigsum & GPGME_SIGSUM_TOFU_CONFLICT) {
         result |= TofuConflict;
     }
     return static_cast<Summary>(result);
 }
 
 const char *GpgME::Signature::fingerprint() const
 {
-    return isNull() ? 0 : d->sigs[idx]->fpr ;
+    return isNull() ? nullptr : d->sigs[idx]->fpr ;
 }
 
 GpgME::Error GpgME::Signature::status() const
 {
     return Error(isNull() ? 0 : d->sigs[idx]->status);
 }
 
 time_t GpgME::Signature::creationTime() const
 {
     return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->timestamp);
 }
 
 time_t GpgME::Signature::expirationTime() const
 {
     return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->exp_timestamp);
 }
 
 bool GpgME::Signature::neverExpires() const
 {
     return expirationTime() == (time_t)0;
 }
 
 bool GpgME::Signature::isWrongKeyUsage() const
 {
     return !isNull() && d->sigs[idx]->wrong_key_usage;
 }
 
 bool GpgME::Signature::isVerifiedUsingChainModel() const
 {
     return !isNull() && d->sigs[idx]->chain_model;
 }
 
 bool GpgME::Signature::isDeVs() const
 {
     return !isNull() && d->sigs[idx]->is_de_vs;
 }
 
 GpgME::Signature::PKAStatus GpgME::Signature::pkaStatus() const
 {
     if (!isNull()) {
         return static_cast<PKAStatus>(d->sigs[idx]->pka_trust);
     }
     return UnknownPKAStatus;
 }
 
 const char *GpgME::Signature::pkaAddress() const
 {
     if (!isNull()) {
         return d->sigs[idx]->pka_address;
     }
-    return 0;
+    return nullptr;
 }
 
 GpgME::Signature::Validity GpgME::Signature::validity() const
 {
     if (isNull()) {
         return Unknown;
     }
     switch (d->sigs[idx]->validity) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return Unknown;
     case GPGME_VALIDITY_UNDEFINED: return Undefined;
     case GPGME_VALIDITY_NEVER:     return Never;
     case GPGME_VALIDITY_MARGINAL:  return Marginal;
     case GPGME_VALIDITY_FULL:      return Full;
     case GPGME_VALIDITY_ULTIMATE:  return Ultimate;
     }
 }
 
 char GpgME::Signature::validityAsString() const
 {
     if (isNull()) {
         return '?';
     }
     switch (d->sigs[idx]->validity) {
     default:
     case GPGME_VALIDITY_UNKNOWN:   return '?';
     case GPGME_VALIDITY_UNDEFINED: return 'q';
     case GPGME_VALIDITY_NEVER:     return 'n';
     case GPGME_VALIDITY_MARGINAL:  return 'm';
     case GPGME_VALIDITY_FULL:      return 'f';
     case GPGME_VALIDITY_ULTIMATE:  return 'u';
     }
 }
 
 GpgME::Error GpgME::Signature::nonValidityReason() const
 {
     return Error(isNull() ? 0 : d->sigs[idx]->validity_reason);
 }
 
 unsigned int GpgME::Signature::publicKeyAlgorithm() const
 {
     if (!isNull()) {
         return d->sigs[idx]->pubkey_algo;
     }
     return 0;
 }
 
 const char *GpgME::Signature::publicKeyAlgorithmAsString() const
 {
     if (!isNull()) {
         return gpgme_pubkey_algo_name(d->sigs[idx]->pubkey_algo);
     }
-    return 0;
+    return nullptr;
 }
 
 unsigned int GpgME::Signature::hashAlgorithm() const
 {
     if (!isNull()) {
         return d->sigs[idx]->hash_algo;
     }
     return 0;
 }
 
 const char *GpgME::Signature::hashAlgorithmAsString() const
 {
     if (!isNull()) {
         return gpgme_hash_algo_name(d->sigs[idx]->hash_algo);
     }
-    return 0;
+    return nullptr;
 }
 
 const char *GpgME::Signature::policyURL() const
 {
-    return isNull() ? 0 : d->purls[idx] ;
+    return isNull() ? nullptr : d->purls[idx] ;
 }
 
 GpgME::Notation GpgME::Signature::notation(unsigned int nidx) const
 {
     return GpgME::Notation(d, idx, nidx);
 }
 
 std::vector<GpgME::Notation> GpgME::Signature::notations() const
 {
     if (isNull()) {
         return std::vector<GpgME::Notation>();
     }
     std::vector<GpgME::Notation> result;
     result.reserve(d->nota[idx].size());
     for (unsigned int i = 0 ; i < d->nota[idx].size() ; ++i) {
         result.push_back(GpgME::Notation(d, idx, i));
     }
     return result;
 }
 
 GpgME::Key GpgME::Signature::key() const
 {
     if (isNull()) {
         return Key();
     }
     return d->keys[idx];
 }
 
 GpgME::Key GpgME::Signature::key(bool search, bool update) const
 {
     if (isNull()) {
         return Key();
     }
 
     GpgME::Key ret = key();
     if (ret.isNull() && search && fingerprint ()) {
         auto ctx = Context::createForProtocol (d->proto);
         if (ctx) {
             ctx->setKeyListMode(KeyListMode::Local |
                         KeyListMode::Signatures |
                         KeyListMode::SignatureNotations |
                         KeyListMode::Validate |
                         KeyListMode::WithTofu);
             Error e;
             ret = d->keys[idx] = ctx->key(fingerprint(), e, false);
             delete ctx;
         }
     }
     if (update) {
         d->keys[idx].update();
         ret = d->keys[idx];
     }
     return ret;
 }
 
 class GpgME::Notation::Private
 {
 public:
-    Private() : d(), sidx(0), nidx(0), nota(0) {}
+    Private() : d(), sidx(0), nidx(0), nota(nullptr) {}
     Private(const std::shared_ptr<VerificationResult::Private> &priv, unsigned int sindex, unsigned int nindex)
-        : d(priv), sidx(sindex), nidx(nindex), nota(0)
+        : d(priv), sidx(sindex), nidx(nindex), nota(nullptr)
     {
 
     }
     Private(gpgme_sig_notation_t n)
-        : d(), sidx(0), nidx(0), nota(n ? new _gpgme_sig_notation(*n) : 0)
+        : d(), sidx(0), nidx(0), nota(n ? new _gpgme_sig_notation(*n) : nullptr)
     {
         if (nota && nota->name) {
             nota->name = strdup(nota->name);
         }
         if (nota && nota->value) {
             nota->value = strdup(nota->value);
         }
     }
     Private(const Private &other)
         : d(other.d), sidx(other.sidx), nidx(other.nidx), nota(other.nota)
     {
         if (nota) {
             nota->name = strdup(nota->name);
             nota->value = strdup(nota->value);
         }
     }
     ~Private()
     {
         if (nota) {
-            std::free(nota->name);  nota->name = 0;
-            std::free(nota->value); nota->value = 0;
+            std::free(nota->name);  nota->name = nullptr;
+            std::free(nota->value); nota->value = nullptr;
             delete nota;
         }
     }
 
     std::shared_ptr<VerificationResult::Private> d;
     unsigned int sidx, nidx;
     gpgme_sig_notation_t nota;
 };
 
 GpgME::Notation::Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex)
     : d(new Private(parent, sindex, nindex))
 {
 
 }
 
 GpgME::Notation::Notation(gpgme_sig_notation_t nota)
     : d(new Private(nota))
 {
 
 }
 
 GpgME::Notation::Notation() : d() {}
 
 bool GpgME::Notation::isNull() const
 {
     if (!d) {
         return true;
     }
     if (d->d) {
         return d->sidx >= d->d->nota.size() || d->nidx >= d->d->nota[d->sidx].size() ;
     }
     return !d->nota;
 }
 
 const char *GpgME::Notation::name() const
 {
     return
-        isNull() ? 0 :
+        isNull() ? nullptr :
         d->d ? d->d->nota[d->sidx][d->nidx].name :
-        d->nota ? d->nota->name : 0 ;
+        d->nota ? d->nota->name : nullptr ;
 }
 
 const char *GpgME::Notation::value() const
 {
     return
-        isNull() ? 0 :
+        isNull() ? nullptr :
         d->d ? d->d->nota[d->sidx][d->nidx].value :
-        d->nota ? d->nota->value : 0 ;
+        d->nota ? d->nota->value : nullptr ;
 }
 
 GpgME::Notation::Flags GpgME::Notation::flags() const
 {
     return
         convert_from_gpgme_sig_notation_flags_t(
-            isNull() ? 0 :
+            isNull() ? 0:
             d->d ? d->d->nota[d->sidx][d->nidx].flags :
             d->nota ? d->nota->flags : 0);
 }
 
 bool GpgME::Notation::isHumanReadable() const
 {
     return flags() & HumanReadable;
 }
 
 bool GpgME::Notation::isCritical() const
 {
     return flags() & Critical;
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const VerificationResult &result)
 {
     os << "GpgME::VerificationResult(";
     if (!result.isNull()) {
         os << "\n error:      " << result.error()
            << "\n fileName:   " << protect(result.fileName())
            << "\n signatures:\n";
         const std::vector<Signature> sigs = result.signatures();
         std::copy(sigs.begin(), sigs.end(),
                   std::ostream_iterator<Signature>(os, "\n"));
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, Signature::PKAStatus pkaStatus)
 {
 #define OUTPUT( x ) if ( !(pkaStatus & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
     os << "GpgME::Signature::PKAStatus(";
     OUTPUT(UnknownPKAStatus);
     OUTPUT(PKAVerificationFailed);
     OUTPUT(PKAVerificationSucceeded);
 #undef OUTPUT
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, Signature::Summary summary)
 {
 #define OUTPUT( x ) if ( !(summary & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
     os << "GpgME::Signature::Summary(";
     OUTPUT(Valid);
     OUTPUT(Green);
     OUTPUT(Red);
     OUTPUT(KeyRevoked);
     OUTPUT(KeyExpired);
     OUTPUT(SigExpired);
     OUTPUT(KeyMissing);
     OUTPUT(CrlMissing);
     OUTPUT(CrlTooOld);
     OUTPUT(BadPolicy);
     OUTPUT(SysError);
     OUTPUT(TofuConflict);
 #undef OUTPUT
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const Signature &sig)
 {
     os << "GpgME::Signature(";
     if (!sig.isNull()) {
         os << "\n Summary:                   " << sig.summary()
            << "\n Fingerprint:               " << protect(sig.fingerprint())
            << "\n Status:                    " << sig.status()
            << "\n creationTime:              " << sig.creationTime()
            << "\n expirationTime:            " << sig.expirationTime()
            << "\n isWrongKeyUsage:           " << sig.isWrongKeyUsage()
            << "\n isVerifiedUsingChainModel: " << sig.isVerifiedUsingChainModel()
            << "\n pkaStatus:                 " << sig.pkaStatus()
            << "\n pkaAddress:                " << protect(sig.pkaAddress())
            << "\n validity:                  " << sig.validityAsString()
            << "\n nonValidityReason:         " << sig.nonValidityReason()
            << "\n publicKeyAlgorithm:        " << protect(sig.publicKeyAlgorithmAsString())
            << "\n hashAlgorithm:             " << protect(sig.hashAlgorithmAsString())
            << "\n policyURL:                 " << protect(sig.policyURL())
            << "\n isDeVs                     " << sig.isDeVs()
            << "\n notations:\n";
         const std::vector<Notation> nota = sig.notations();
         std::copy(nota.begin(), nota.end(),
                   std::ostream_iterator<Notation>(os, "\n"));
     }
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, Notation::Flags flags)
 {
     os << "GpgME::Notation::Flags(";
 #define OUTPUT( x ) if ( !(flags & (GpgME::Notation:: x)) ) {} else do { os << #x " "; } while(0)
     OUTPUT(HumanReadable);
     OUTPUT(Critical);
 #undef OUTPUT
     return os << ')';
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const Notation &nota)
 {
     os << "GpgME::Signature::Notation(";
     if (!nota.isNull()) {
         os << "\n name:  " << protect(nota.name())
            << "\n value: " << protect(nota.value())
            << "\n flags: " << nota.flags()
            << '\n';
     }
     return os << ")";
 }
diff --git a/lang/cpp/src/vfsmountresult.cpp b/lang/cpp/src/vfsmountresult.cpp
index 60faa385..901ccfe2 100644
--- a/lang/cpp/src/vfsmountresult.cpp
+++ b/lang/cpp/src/vfsmountresult.cpp
@@ -1,96 +1,96 @@
 /*
   vfsmountresult.cpp - wraps a gpgme vfs mount result
   Copyright (C) 2009 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH <info@kdab.com>
   Author: Marc Mutz <marc@kdab.com>, Volker Krause <volker@kdab.com>
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include <vfsmountresult.h>
 #include "result_p.h"
 
 #include <gpgme.h>
 
 #include <istream>
 #include <string.h>
 
 using namespace GpgME;
 
 class VfsMountResult::Private
 {
 public:
-    explicit Private(const gpgme_vfs_mount_result_t r) : mountDir(0)
+    explicit Private(const gpgme_vfs_mount_result_t r) : mountDir(nullptr)
     {
         if (r && r->mount_dir) {
             mountDir = strdup(r->mount_dir);
         }
     }
 
     ~Private()
     {
         std::free(mountDir);
     }
 
     char *mountDir;
 };
 
 VfsMountResult::VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError)
     : Result(error ? error : opError), d()
 {
     init(ctx);
 }
 
 void VfsMountResult::init(gpgme_ctx_t ctx)
 {
     (void)ctx;
     if (!ctx) {
         return;
     }
     gpgme_vfs_mount_result_t res = gpgme_op_vfs_mount_result(ctx);
     if (!res) {
         return;
     }
     d.reset(new Private(res));
 }
 
 make_standard_stuff(VfsMountResult)
 
 const char *VfsMountResult::mountDir() const
 {
     if (d) {
         return d->mountDir;
     }
-    return 0;
+    return nullptr;
 }
 
 std::ostream &GpgME::operator<<(std::ostream &os, const VfsMountResult &result)
 {
     os << "GpgME::VfsMountResult(";
     if (!result.isNull()) {
         os << "\n error:       " << result.error()
            << "\n mount dir: " << result.mountDir()
            << "\n";
     }
     return os << ')';
 }
diff --git a/lang/qt/src/Makefile.am b/lang/qt/src/Makefile.am
index 32251424..80dcde15 100644
--- a/lang/qt/src/Makefile.am
+++ b/lang/qt/src/Makefile.am
@@ -1,277 +1,278 @@
 # Makefile.am for GPGMEPP.
 # Copyright (C) 2016 Bundesamt für Sicherheit in der Informationstechnik
 # Software engineering by Intevation GmbH
 #
 # This file is part of GPGMEPP.
 #
 # GPGME-CL is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME-CL is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Lesser General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 # 02111-1307, USA
 lib_LTLIBRARIES = libqgpgme.la
 EXTRA_DIST = QGpgmeConfig.cmake.in.in QGpgmeConfigVersion.cmake.in \
              gpgme_backend_debug.h qgpgme_version.h.in \
              QGpgmeConfig.cmake.in.in
 
 qgpgme_sources = \
     dataprovider.cpp job.cpp multideletejob.cpp qgpgmeadduseridjob.cpp \
     qgpgmebackend.cpp qgpgmechangeexpiryjob.cpp qgpgmechangeownertrustjob.cpp \
     qgpgmechangepasswdjob.cpp qgpgmedecryptjob.cpp \
     qgpgmedecryptverifyjob.cpp qgpgmedeletejob.cpp qgpgmedownloadjob.cpp \
     qgpgmeencryptjob.cpp qgpgmeexportjob.cpp qgpgmeimportfromkeyserverjob.cpp \
     qgpgmeimportjob.cpp qgpgmekeygenerationjob.cpp qgpgmekeylistjob.cpp \
     qgpgmelistallkeysjob.cpp qgpgmenewcryptoconfig.cpp \
     qgpgmerefreshkeysjob.cpp \
     qgpgmesecretkeyexportjob.cpp qgpgmesignencryptjob.cpp \
     qgpgmesignjob.cpp qgpgmesignkeyjob.cpp qgpgmeverifydetachedjob.cpp \
     qgpgmeverifyopaquejob.cpp threadedjobmixin.cpp \
     qgpgmekeyformailboxjob.cpp gpgme_backend_debug.cpp \
     qgpgmetofupolicyjob.cpp qgpgmequickjob.cpp \
     defaultkeygenerationjob.cpp qgpgmewkspublishjob.cpp \
     dn.cpp cryptoconfig.cpp
 
 # If you add one here make sure that you also add one in camelcase
 qgpgme_headers= \
     abstractimportjob.h \
     adduseridjob.h \
     changeexpiryjob.h \
     changeownertrustjob.h \
     changepasswdjob.h \
     dataprovider.h \
     decryptjob.h \
     decryptverifyjob.h \
     downloadjob.h \
     encryptjob.h \
     exportjob.h \
     hierarchicalkeylistjob.h \
     job.h \
     keyformailboxjob.h \
     multideletejob.h \
     protocol.h \
     qgpgme_export.h \
     qgpgmenewcryptoconfig.h \
     quickjob.h \
     specialjob.h \
     signjob.h \
     signkeyjob.h \
     signencryptjob.h \
     verifyopaquejob.h \
     refreshkeysjob.h \
     cryptoconfig.h \
     deletejob.h \
     importfromkeyserverjob.h \
     importjob.h \
     keygenerationjob.h \
     keylistjob.h \
     listallkeysjob.h \
     verifydetachedjob.h \
     defaultkeygenerationjob.h \
     tofupolicyjob.h \
     wkspublishjob.h \
     dn.h
 
 camelcase_headers= \
     AddUserIDJob \
     AbstractImportJob \
     ChangeExpiryJob \
     ChangeOwnerTrustJob \
     ChangePasswdJob \
     DataProvider \
     DecryptJob \
     DecryptVerifyJob \
     DN \
     DownloadJob \
     EncryptJob \
     ExportJob \
     HierarchicalKeyKistJob \
     Job \
     MultiDeleteJob \
     Protocol \
     QGpgMENewCryptoConfig \
     QuickJob \
     SpecialJob \
     SignJob \
     SignKeyJob \
     SignEncryptJob \
     VerifyOpaqueJob \
     RefreshKeysJob \
     CryptoConfig \
     DeleteJob \
     ImportFromKeyserverJob \
     ImportJob \
     KeyGenerationJob \
     KeyListJob \
     ListAllKeysJob \
     VerifyDetachedJob \
     KeyForMailboxJob \
     DefaultKeyGenerationJob \
     WKSPublishJob \
     TofuPolicyJob
 
 private_qgpgme_headers = \
     qgpgme_export.h \
     protocol_p.h \
     qgpgmeadduseridjob.h \
     qgpgmebackend.h \
     qgpgmechangeexpiryjob.h \
     qgpgmechangeownertrustjob.h \
     qgpgmechangepasswdjob.h \
     qgpgmedecryptjob.h \
     qgpgmedecryptverifyjob.h \
     qgpgmedeletejob.h \
     qgpgmedownloadjob.h \
     qgpgmeencryptjob.h \
     qgpgmeexportjob.h \
     qgpgmeimportfromkeyserverjob.h \
     qgpgmeimportjob.h \
     qgpgmekeygenerationjob.h \
     qgpgmekeylistjob.h \
     qgpgmelistallkeysjob.h \
     qgpgmerefreshkeysjob.h \
     qgpgmesecretkeyexportjob.h \
     qgpgmesignencryptjob.h \
     qgpgmesignjob.h \
     qgpgmesignkeyjob.h \
     qgpgmeverifydetachedjob.h \
     qgpgmeverifyopaquejob.h \
     qgpgmekeyformailboxjob.h \
     qgpgmewkspublishjob.h \
     qgpgmetofupolicyjob.h \
     qgpgmequickjob.h \
     threadedjobmixin.h
 
 qgpgme_moc_sources = \
     abstractimportjob.moc \
     adduseridjob.moc \
     changeexpiryjob.moc \
     changeownertrustjob.moc \
     changepasswdjob.moc \
     decryptjob.moc \
     decryptverifyjob.moc \
     deletejob.moc \
     downloadjob.moc \
     encryptjob.moc \
     exportjob.moc \
     hierarchicalkeylistjob.moc \
     importfromkeyserverjob.moc \
     importjob.moc \
     job.moc \
     keygenerationjob.moc \
     keylistjob.moc \
     listallkeysjob.moc \
     multideletejob.moc \
     qgpgmeadduseridjob.moc \
     qgpgmechangeexpiryjob.moc \
     qgpgmechangeownertrustjob.moc \
     qgpgmechangepasswdjob.moc \
     qgpgmedecryptjob.moc \
     qgpgmedecryptverifyjob.moc \
     qgpgmedeletejob.moc \
     qgpgmedownloadjob.moc \
     qgpgmeencryptjob.moc \
     qgpgmeexportjob.moc \
     qgpgmeimportfromkeyserverjob.moc \
     qgpgmeimportjob.moc \
     qgpgmekeygenerationjob.moc \
     qgpgmekeylistjob.moc \
     qgpgmelistallkeysjob.moc \
     qgpgmerefreshkeysjob.moc \
     qgpgmesecretkeyexportjob.moc \
     qgpgmesignencryptjob.moc \
     qgpgmesignjob.moc \
     qgpgmesignkeyjob.moc \
     qgpgmeverifydetachedjob.moc \
     qgpgmeverifyopaquejob.moc \
     qgpgmewkspublishjob.moc \
     tofupolicyjob.moc \
     qgpgmetofupolicyjob.moc \
     refreshkeysjob.moc \
     signencryptjob.moc \
     signjob.moc \
     signkeyjob.moc \
     specialjob.moc \
     verifydetachedjob.moc \
     verifyopaquejob.moc \
     keyformailboxjob.moc \
     wkspublishjob.moc \
     qgpgmekeyformailboxjob.moc \
     defaultkeygenerationjob.moc \
     quickjob.moc \
     qgpgmequickjob.moc
 
 qgpgmeincludedir = $(includedir)/qgpgme
 qgpgmeinclude_HEADERS = $(qgpgme_headers)
 camelcaseincludedir = $(includedir)/QGpgME
 camelcaseinclude_HEADERS = $(camelcase_headers)
 nodist_qgpgmeinclude_HEADERS = qgpgme_version.h
 
 libqgpgme_la_SOURCES = $(qgpgme_sources) $(qgpgme_headers) $(private_qgpgme_headers)
 
 AM_CPPFLAGS = -I$(top_srcdir)/lang/cpp/src -I$(top_builddir)/src \
               @GPGME_QT_CFLAGS@ @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ \
-              -DBUILDING_QGPGME
+              -DBUILDING_QGPGME -Wsuggest-override \
+              -Wzero-as-null-pointer-constant
 
 libqgpgme_la_LIBADD = ../../cpp/src/libgpgmepp.la ../../../src/libgpgme.la \
                        @LIBASSUAN_LIBS@ @GPGME_QT_LIBS@
 libqgpgme_la_LDFLAGS = -no-undefined -version-info \
     @LIBQGPGME_LT_CURRENT@:@LIBQGPGME_LT_REVISION@:@LIBQGPGME_LT_AGE@
 
 if HAVE_MACOS_SYSTEM
 libsuffix=.dylib
 else
 libsuffix=.so
 endif
 
 if HAVE_W32_SYSTEM
 QGpgmeConfig.cmake: QGpgmeConfig-w32.cmake.in
 	sed -e 's|[@]resolved_bindir@|$(bindir)|g' < "$<" | \
 	sed -e 's|[@]resolved_libdir@|$(libdir)|g' | \
 	sed -e 's|[@]resolved_includedir@|$(includedir)|g' > $@
 else
 QGpgmeConfig.cmake: QGpgmeConfig.cmake.in
 	sed -e 's|[@]resolved_libdir@|$(libdir)|g' < "$<" | \
 	sed -e 's|[@]libsuffix@|$(libsuffix)|g' | \
 	sed -e 's|[@]resolved_includedir@|$(includedir)|g' > $@
 endif
 
 $(camelcase_headers): Makefile.am
 	echo -n "#include \"qgpgme/" > "$@"
 	echo -n "$@" | tr '[:upper:]' '[:lower:]' >> "$@"
 	echo ".h\"" >> "$@"
 
 install-cmake-files: QGpgmeConfig.cmake QGpgmeConfigVersion.cmake
 	-$(INSTALL) -d $(DESTDIR)$(libdir)/cmake/QGpgme
 	$(INSTALL) -m 644 QGpgmeConfig.cmake \
         $(DESTDIR)$(libdir)/cmake/QGpgme/QGpgmeConfig.cmake
 	$(INSTALL) -m 644 QGpgmeConfigVersion.cmake \
         $(DESTDIR)$(libdir)/cmake/QGpgme/QGpgmeConfigVersion.cmake
 
 uninstall-cmake-files:
 	-rm $(DESTDIR)$(libdir)/cmake/QGpgme/QGpgmeConfigVersion.cmake
 	-rm $(DESTDIR)$(libdir)/cmake/QGpgme/QGpgmeConfig.cmake
 	-rmdir $(DESTDIR)$(libdir)/cmake/QGpgme/
 
 install-data-local: install-cmake-files
 
 uninstall-local: uninstall-cmake-files
 
 BUILT_SOURCES = $(qgpgme_moc_sources) $(camelcase_headers)
 
 CLEANFILES = $(qgpgme_moc_sources) $(camelcase_headers) QGpgmeConfig.cmake \
              qgpgme_version.h QGpgmeConfig.cmake.in \
              QGpgmeConfigVersion.cmake
 
 nodist_libqgpgme_la_SOURCES = $(qgpgme_moc_sources)
 
 .h.moc:
 	$(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@
diff --git a/lang/qt/src/cryptoconfig.h b/lang/qt/src/cryptoconfig.h
index d545e597..d7aae9d7 100644
--- a/lang/qt/src/cryptoconfig.h
+++ b/lang/qt/src/cryptoconfig.h
@@ -1,409 +1,409 @@
 /*
     cryptoconfig.h
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifndef CRYPTOCONFIG_H
 #define CRYPTOCONFIG_H
 
 #include "qgpgme_export.h"
 #ifdef __cplusplus
 /* we read this file from a C compiler, and are only interested in the
  * enums... */
 
 #include <QUrl>
 
 #include <vector>
 
 /* Start reading this file from the bottom up :) */
 
 namespace QGpgME
 {
 
 /**
  * Description of a single option
  */
 class QGPGME_EXPORT CryptoConfigEntry
 {
 
 public:
 #endif /* __cplusplus */
     /**
        @li basic        This option should always be offered to the user.
        @li advanced        This option may be offered to advanced users.
        @li expert        This option should only be offered to expert users.
        */
     enum Level { Level_Basic = 0,
                  Level_Advanced = 1,
                  Level_Expert = 2
                };
 
     /**
        Type of the argument
        @li ArgType_None        The option is set or not set, but no argument.
        @li ArgType_String        An unformatted string.
        @li ArgType_Int                A signed integer number.
        @li ArgType_UInt        An unsigned integer number.
        @li ArgType_Path        A string that describes the pathname of a file.
        The file does not necessarily need to exist.
        Separated from string so that e.g. a FileDialog can be used.
        @li ArgType_DirPath        A string that describes the pathname of a directory.
        The directory does not necessarily need to exist.
        Separated from path so that e.g. a FileDialog can be used which only
        allows directories to be selected.
        @li ArgType_LDAPURL        A LDAP URL
        Separated from URL so that a more specific widget can be shown, hiding the url syntax
     */
     enum ArgType { ArgType_None = 0,
                    ArgType_String = 1,
                    ArgType_Int = 2,
                    ArgType_UInt = 3,
                    ArgType_Path = 4,
                    /* Nr. 5 was URL historically. */
                    ArgType_LDAPURL = 6,
                    ArgType_DirPath = 7,
 
                    NumArgType
                  };
 
 #ifdef __cplusplus
     virtual ~CryptoConfigEntry() {}
 
     /**
      * Return the internal name of this entry
      */
     virtual QString name() const = 0;
 
     /**
      * @return user-visible description of this entry
      */
     virtual QString description() const = 0;
 
     /**
      * @return "component/group/name"
      */
     virtual QString path() const = 0;
 
     /**
      * @return true if the argument is optional
      */
     virtual bool isOptional() const = 0;
 
     /**
      * @return true if the entry is readonly
      */
     virtual bool isReadOnly() const = 0;
 
     /**
      * @return true if the argument can be given multiple times
      */
     virtual bool isList() const = 0;
 
     /**
      * @return true if the argument can be changed at runtime
      */
     virtual bool isRuntime() const = 0;
 
     /**
      * User level
      */
     virtual Level level() const = 0;
 
     /**
      * Argument type
      */
     virtual ArgType argType() const = 0;
 
     /**
      * Return true if the option is set, i.e. different from default
      */
     virtual bool isSet() const = 0;
 
     /**
      * Return value as a bool (only allowed for ArgType_None)
      */
     virtual bool boolValue() const = 0;
 
     /**
      * Return value as a string (available for all argtypes)
      * The returned string can be empty (explicitly set to empty) or null (not set).
      */
     virtual QString stringValue() const = 0;
 
     /**
      * Return value as a signed int
      */
     virtual int intValue() const = 0;
 
     /**
      * Return value as an unsigned int
      */
     virtual unsigned int uintValue() const = 0;
 
     /**
      * Return value as a URL (only meaningful for Path and URL argtypes)
      */
     virtual QUrl urlValue() const = 0;
 
     /**
      * Return number of times the option is set (only valid for ArgType_None, if isList())
      */
     virtual unsigned int numberOfTimesSet() const = 0;
 
     /**
      * Return value as a list of signed ints
      */
     virtual std::vector<int> intValueList() const = 0;
 
     /**
      * Return value as a list of unsigned ints
      */
     virtual std::vector<unsigned int> uintValueList() const = 0;
 
     /**
      * Return value as a list of URLs (only meaningful for Path and URL argtypes, if isList())
      */
     virtual QList<QUrl> urlValueList() const = 0;
 
     /**
      * Reset an option to its default value
      */
     virtual void resetToDefault() = 0;
 
     /**
      * Define whether the option is set or not (only allowed for ArgType_None)
      * #### TODO: and for options with optional args
      */
     virtual void setBoolValue(bool) = 0;
 
     /**
      * Set string value (allowed for all argtypes)
      */
     virtual void setStringValue(const QString &) = 0;
 
     /**
      * Set a new signed int value
      */
     virtual void setIntValue(int) = 0;
 
     /**
      * Set a new unsigned int value
      */
     virtual void setUIntValue(unsigned int) = 0;
 
     /**
      * Set value as a URL (only meaningful for Path (if local) and URL argtypes)
      */
     virtual void setURLValue(const QUrl &) = 0;
 
     /**
      * Set the number of times the option is set (only valid for ArgType_None, if isList())
      */
     virtual void setNumberOfTimesSet(unsigned int) = 0;
 
     /**
      * Set a new list of signed int values
      */
     virtual void setIntValueList(const std::vector<int> &) = 0;
 
     /**
      * Set a new list of unsigned int values
      */
     virtual void setUIntValueList(const std::vector<unsigned int> &) = 0;
 
     /**
      * Set value as a URL list (only meaningful for Path (if all URLs are local) and URL argtypes, if isList())
      */
     virtual void setURLValueList(const QList<QUrl> &) = 0;
 
     /**
      * @return true if the value was changed
      */
     virtual bool isDirty() const = 0;
 
     // Design change from here on we are closely bound to one implementation
     // of cryptoconfig. To avoid ABI breaks with every new function we
     // add real functions from now on.
 
     /**
      * @return a stringValueList.
      */
     QStringList stringValueList() const;
 };
 
 /**
  * Group containing a set of config options
  */
 class QGPGME_EXPORT CryptoConfigGroup
 {
 
 public:
     virtual ~CryptoConfigGroup() {}
 
     /**
      * Return the internal name of this group
      */
     virtual QString name() const = 0;
 
     /**
      * Return the name of the icon for this group
      */
     virtual QString iconName() const = 0;
 
     /**
      * @return user-visible description of this group
      */
     virtual QString description() const = 0;
 
     /**
      * @return "component/group"
      */
     virtual QString path() const = 0;
 
     /**
      * User level
      */
     virtual CryptoConfigEntry::Level level() const = 0;
 
     /**
      * Returns the list of entries that are known by this group.
      *
      * @return list of group entry names.
      **/
     virtual QStringList entryList() const = 0;
 
     /**
      * @return the configuration object for a given entry in this group
      * The object is owned by CryptoConfigGroup, don't delete it.
      * Groups cannot be nested, so all entries returned here are pure entries, no groups.
      */
     virtual CryptoConfigEntry *entry(const QString &name) const = 0;
 };
 
 /**
  * Crypto config for one component (e.g. gpg-agent, dirmngr etc.)
  */
 class QGPGME_EXPORT CryptoConfigComponent
 {
 
 public:
     virtual ~CryptoConfigComponent() {}
 
     /**
      * Return the internal name of this component
      */
     virtual QString name() const = 0;
 
     /**
      * Return the name of the icon for this component
      */
     virtual QString iconName() const = 0;
 
     /**
      * Return user-visible description of this component
      */
     virtual QString description() const = 0;
 
     /**
      * Returns the list of groups that are known about.
      *
      * @return list of group names. One of them can be "<nogroup>", which is the group where all
      * "toplevel" options (belonging to no group) are.
      */
     virtual QStringList groupList() const = 0;
 
     /**
      * @return the configuration object for a given group
      * The object is owned by CryptoConfigComponent, don't delete it.
      */
     virtual CryptoConfigGroup *group(const QString &name) const = 0;
 
 };
 
 /**
  * Main interface to crypto configuration.
  */
 class QGPGME_EXPORT CryptoConfig
 {
 
 public:
     virtual ~CryptoConfig() {}
 
     /**
      * Returns the list of known components (e.g. "gpg-agent", "dirmngr" etc.).
      * Use @ref component() to retrieve more information about each one.
      * @return list of component names.
      **/
     virtual QStringList componentList() const = 0;
 
     /**
      * @return the configuration object for a given component
      * The object is owned by CryptoConfig, don't delete it.
      */
     virtual CryptoConfigComponent *component(const QString &name) const = 0;
 
     /**
      * Convenience method to get hold of a single configuration entry when
      * its component, group and name are known. This can be used to read
      * the value and/or to set a value to it.
      *
      * @return the configuration object for a single configuration entry, 0 if not found.
      * The object is owned by CryptoConfig, don't delete it.
      */
     CryptoConfigEntry *entry(const QString &componentName, const QString &groupName, const QString &entryName) const
     {
         const QGpgME::CryptoConfigComponent *comp = component(componentName);
-        const QGpgME::CryptoConfigGroup *group = comp ? comp->group(groupName) : 0;
-        return group ? group->entry(entryName) : 0;
+        const QGpgME::CryptoConfigGroup *group = comp ? comp->group(groupName) : nullptr;
+        return group ? group->entry(entryName) : nullptr;
     }
 
     /**
      * Write back changes
      *
      * @param runtime this parameter is ignored. Changes will always
      * be made with --runtime set.
      */
     virtual void sync(bool runtime) = 0;
 
     /**
      * Tells the CryptoConfig to discard any cached information, including
      * all components, groups and entries.
      * Call this to free some memory when you won't be using the object
      * for some time.
      * DON'T call this if you're holding pointers to components, groups or entries.
      */
     virtual void clear() = 0;
 };
 
 }
 #endif /* __cplusplus */
 #endif /* CRYPTOCONFIG_H */
diff --git a/lang/qt/src/dataprovider.h b/lang/qt/src/dataprovider.h
index 980a6a98..636d6fb6 100644
--- a/lang/qt/src/dataprovider.h
+++ b/lang/qt/src/dataprovider.h
@@ -1,96 +1,96 @@
 /* dataprovider.h
    Copyright (C) 2004 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
    This file is part of QGPGME.
 
    QGPGME is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published
    by the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    QGPGME is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with QGPGME; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA. */
 
 // -*- c++ -*-
 #ifndef __QGPGME_DATAPROVIDER_H__
 #define __QGPGME_DATAPROVIDER_H__
 
 #include "qgpgme_export.h"
 #include <interfaces/dataprovider.h>
 #include <memory>
 
 #include <QtCore/QByteArray>
 
 
 class QIODevice;
 
 namespace QGpgME
 {
 
 class QGPGME_EXPORT QByteArrayDataProvider : public GpgME::DataProvider
 {
 public:
     QByteArrayDataProvider();
     explicit QByteArrayDataProvider(const QByteArray &initialData);
     ~QByteArrayDataProvider();
 
     const QByteArray &data() const
     {
         return mArray;
     }
 
 private:
     // these shall only be accessed through the dataprovider
     // interface, where they're public:
-    bool isSupported(Operation) const
+    bool isSupported(Operation) const override
     {
         return true;
     }
-    ssize_t read(void *buffer, size_t bufSize);
-    ssize_t write(const void *buffer, size_t bufSize);
-    off_t seek(off_t offset, int whence);
-    void release();
+    ssize_t read(void *buffer, size_t bufSize) override;
+    ssize_t write(const void *buffer, size_t bufSize) override;
+    off_t seek(off_t offset, int whence) override;
+    void release() override;
 
 private:
     QByteArray mArray;
     off_t mOff;
 };
 
 class QGPGME_EXPORT QIODeviceDataProvider : public GpgME::DataProvider
 {
 public:
     explicit QIODeviceDataProvider(const std::shared_ptr<QIODevice> &initialData);
     ~QIODeviceDataProvider();
 
     const std::shared_ptr<QIODevice> &ioDevice() const
     {
         return mIO;
     }
 
 private:
     // these shall only be accessed through the dataprovider
     // interface, where they're public:
-    bool isSupported(Operation) const;
-    ssize_t read(void *buffer, size_t bufSize);
-    ssize_t write(const void *buffer, size_t bufSize);
-    off_t seek(off_t offset, int whence);
-    void release();
+    bool isSupported(Operation) const override;
+    ssize_t read(void *buffer, size_t bufSize) override;
+    ssize_t write(const void *buffer, size_t bufSize) override;
+    off_t seek(off_t offset, int whence) override;
+    void release() override;
 
 private:
     const std::shared_ptr<QIODevice> mIO;
     bool mErrorOccurred : 1;
     bool mHaveQProcess  : 1;
 };
 
 } // namespace QGpgME
 
 #endif
diff --git a/lang/qt/src/dn.cpp b/lang/qt/src/dn.cpp
index d122333d..e41d481c 100644
--- a/lang/qt/src/dn.cpp
+++ b/lang/qt/src/dn.cpp
@@ -1,498 +1,498 @@
 /*
     dn.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "dn.h"
 
 #include <gpg-error.h>
 
 static const struct {
     const char *name;
     const char *oid;
 } oidmap[] = {
     // keep them ordered by oid:
     { "SP", "ST" }, // hack to show the Sphinx-required/desired SP for
     // StateOrProvince, otherwise known as ST or even S
     { "NameDistinguisher", "0.2.262.1.10.7.20" },
     { "EMAIL", "1.2.840.113549.1.9.1" },
     { "SN", "2.5.4.4" },
     { "SerialNumber", "2.5.4.5" },
     { "T", "2.5.4.12" },
     { "D", "2.5.4.13" },
     { "BC", "2.5.4.15" },
     { "ADDR", "2.5.4.16" },
     { "PC", "2.5.4.17" },
     { "GN", "2.5.4.42" },
     { "Pseudo", "2.5.4.65" },
 };
 static const unsigned int numOidMaps = sizeof oidmap / sizeof * oidmap;
 
 class QGpgME::DN::Private
 {
 public:
     Private() : mRefCount(0) {}
     Private(const Private &other)
         : attributes(other.attributes),
           reorderedAttributes(other.reorderedAttributes),
           order{"CN", "L", "_X_", "OU", "O", "C"},
           mRefCount(0)
     {
     }
 
     int ref()
     {
         return ++mRefCount;
     }
 
     int unref()
     {
         if (--mRefCount <= 0) {
             delete this;
             return 0;
         } else {
             return mRefCount;
         }
     }
 
     int refCount() const
     {
         return mRefCount;
     }
 
     DN::Attribute::List attributes;
     DN::Attribute::List reorderedAttributes;
     QStringList order;
 private:
     int mRefCount;
 };
 
 namespace
 {
 struct DnPair {
     char *key;
     char *value;
 };
 }
 
 // copied from CryptPlug and adapted to work on DN::Attribute::List:
 
 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
 #define hexdigitp(a) (digitp (a)                     \
                       || (*(a) >= 'A' && *(a) <= 'F')  \
                       || (*(a) >= 'a' && *(a) <= 'f'))
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 static char *
 trim_trailing_spaces(char *string)
 {
     char *p, *mark;
 
     for (mark = NULL, p = string; *p; p++) {
         if (isspace(*p)) {
             if (!mark) {
                 mark = p;
             }
         } else {
             mark = NULL;
         }
     }
     if (mark) {
         *mark = '\0';
     }
 
     return string;
 }
 
 /* Parse a DN and return an array-ized one.  This is not a validating
    parser and it does not support any old-stylish syntax; gpgme is
    expected to return only rfc2253 compatible strings. */
 static const unsigned char *
 parse_dn_part(DnPair *array, const unsigned char *string)
 {
     const unsigned char *s, *s1;
     size_t n;
     char *p;
 
     /* parse attributeType */
     for (s = string + 1; *s && *s != '='; s++)
         ;
     if (!*s) {
         return NULL;    /* error */
     }
     n = s - string;
     if (!n) {
         return NULL;    /* empty key */
     }
     p = (char *)malloc(n + 1);
 
     memcpy(p, string, n);
     p[n] = 0;
     trim_trailing_spaces((char *)p);
     // map OIDs to their names:
     for (unsigned int i = 0; i < numOidMaps; ++i)
         if (!strcasecmp((char *)p, oidmap[i].oid)) {
             free(p);
             gpgrt_asprintf(&p, "%s", oidmap[i].name);
             break;
         }
     array->key = p;
     string = s + 1;
 
     if (*string == '#') {
         /* hexstring */
         string++;
         for (s = string; hexdigitp(s); s++) {
             s++;
         }
         n = s - string;
         if (!n || (n & 1)) {
             return NULL;    /* empty or odd number of digits */
         }
         n /= 2;
         array->value = p = (char *)malloc(n + 1);
 
         for (s1 = string; n; s1 += 2, n--) {
             *p++ = xtoi_2(s1);
         }
         *p = 0;
     } else {
         /* regular v3 quoted string */
         for (n = 0, s = string; *s; s++) {
             if (*s == '\\') {
                 /* pair */
                 s++;
                 if (*s == ',' || *s == '=' || *s == '+'
                         || *s == '<' || *s == '>' || *s == '#' || *s == ';'
                         || *s == '\\' || *s == '\"' || *s == ' ') {
                     n++;
                 } else if (hexdigitp(s) && hexdigitp(s + 1)) {
                     s++;
                     n++;
                 } else {
                     return NULL;    /* invalid escape sequence */
                 }
             } else if (*s == '\"') {
                 return NULL;    /* invalid encoding */
             } else if (*s == ',' || *s == '=' || *s == '+'
                        || *s == '<' || *s == '>' || *s == '#' || *s == ';') {
                 break;
             } else {
                 n++;
             }
         }
 
         array->value = p = (char *)malloc(n + 1);
 
         for (s = string; n; s++, n--) {
             if (*s == '\\') {
                 s++;
                 if (hexdigitp(s)) {
                     *p++ = xtoi_2(s);
                     s++;
                 } else {
                     *p++ = *s;
                 }
             } else {
                 *p++ = *s;
             }
         }
         *p = 0;
     }
     return s;
 }
 
 /* Parse a DN and return an array-ized one.  This is not a validating
    parser and it does not support any old-stylish syntax; gpgme is
    expected to return only rfc2253 compatible strings. */
 static QGpgME::DN::Attribute::List
 parse_dn(const unsigned char *string)
 {
     if (!string) {
         return QVector<QGpgME::DN::Attribute>();
     }
 
     QVector<QGpgME::DN::Attribute> result;
     while (*string) {
         while (*string == ' ') {
             string++;
         }
         if (!*string) {
             break;    /* ready */
         }
 
-        DnPair pair = { 0, 0 };
+        DnPair pair = { nullptr, nullptr };
         string = parse_dn_part(&pair, string);
         if (!string) {
             goto failure;
         }
         if (pair.key && pair.value)
             result.push_back(QGpgME::DN::Attribute(QString::fromUtf8(pair.key),
                                                  QString::fromUtf8(pair.value)));
         free(pair.key);
         free(pair.value);
 
         while (*string == ' ') {
             string++;
         }
         if (*string && *string != ',' && *string != ';' && *string != '+') {
             goto failure;    /* invalid delimiter */
         }
         if (*string) {
             string++;
         }
     }
     return result;
 
 failure:
     return QVector<QGpgME::DN::Attribute>();
 }
 
 static QVector<QGpgME::DN::Attribute>
 parse_dn(const QString &dn)
 {
     return parse_dn((const unsigned char *)dn.toUtf8().data());
 }
 
 static QString dn_escape(const QString &s)
 {
     QString result;
     for (unsigned int i = 0, end = s.length(); i != end; ++i) {
         const QChar ch = s[i];
         switch (ch.unicode()) {
         case ',':
         case '+':
         case '"':
         case '\\':
         case '<':
         case '>':
         case ';':
             result += QLatin1Char('\\');
         // fall through
         default:
             result += ch;
         }
     }
     return result;
 }
 
 static QString
 serialise(const QVector<QGpgME::DN::Attribute> &dn, const QString &sep)
 {
     QStringList result;
     for (QVector<QGpgME::DN::Attribute>::const_iterator it = dn.begin(); it != dn.end(); ++it)
         if (!(*it).name().isEmpty() && !(*it).value().isEmpty()) {
             result.push_back((*it).name().trimmed() + QLatin1Char('=') + dn_escape((*it).value().trimmed()));
         }
     return result.join(sep);
 }
 
 static QGpgME::DN::Attribute::List
 reorder_dn(const QGpgME::DN::Attribute::List &dn, const QStringList &attrOrder)
 {
     QGpgME::DN::Attribute::List unknownEntries;
     QGpgME::DN::Attribute::List result;
     unknownEntries.reserve(dn.size());
     result.reserve(dn.size());
 
     // find all unknown entries in their order of appearance
     for (QGpgME::DN::const_iterator it = dn.begin(); it != dn.end(); ++it)
         if (!attrOrder.contains((*it).name())) {
             unknownEntries.push_back(*it);
         }
 
     // process the known attrs in the desired order
     for (QStringList::const_iterator oit = attrOrder.begin(); oit != attrOrder.end(); ++oit)
         if (*oit == QLatin1String("_X_")) {
             // insert the unknown attrs
             std::copy(unknownEntries.begin(), unknownEntries.end(),
                       std::back_inserter(result));
             unknownEntries.clear(); // don't produce dup's
         } else {
             for (QGpgME::DN::const_iterator dnit = dn.begin(); dnit != dn.end(); ++dnit)
                 if ((*dnit).name() == *oit) {
                     result.push_back(*dnit);
                 }
         }
 
     return result;
 }
 
 //
 //
 // class DN
 //
 //
 
 QGpgME::DN::DN()
 {
     d = new Private();
     d->ref();
 }
 
 QGpgME::DN::DN(const QString &dn)
 {
     d = new Private();
     d->ref();
     d->attributes = parse_dn(dn);
 }
 
 QGpgME::DN::DN(const char *utf8DN)
 {
     d = new Private();
     d->ref();
     if (utf8DN) {
         d->attributes = parse_dn((const unsigned char *)utf8DN);
     }
 }
 
 QGpgME::DN::DN(const DN &other)
     : d(other.d)
 {
     if (d) {
         d->ref();
     }
 }
 
 QGpgME::DN::~DN()
 {
     if (d) {
         d->unref();
     }
 }
 
 const QGpgME::DN &QGpgME::DN::operator=(const DN &that)
 {
     if (this->d == that.d) {
         return *this;
     }
 
     if (that.d) {
         that.d->ref();
     }
     if (this->d) {
         this->d->unref();
     }
 
     this->d = that.d;
 
     return *this;
 }
 
 QString QGpgME::DN::prettyDN() const
 {
     if (!d) {
         return QString();
     }
     if (d->reorderedAttributes.empty()) {
         d->reorderedAttributes = reorder_dn(d->attributes, d->order);
     }
     return serialise(d->reorderedAttributes, QStringLiteral(","));
 }
 
 QString QGpgME::DN::dn() const
 {
     return d ? serialise(d->attributes, QStringLiteral(",")) : QString();
 }
 
 QString QGpgME::DN::dn(const QString &sep) const
 {
     return d ? serialise(d->attributes, sep) : QString();
 }
 
 // static
 QString QGpgME::DN::escape(const QString &value)
 {
     return dn_escape(value);
 }
 
 void QGpgME::DN::detach()
 {
     if (!d) {
         d = new QGpgME::DN::Private();
         d->ref();
     } else if (d->refCount() > 1) {
         QGpgME::DN::Private *d_save = d;
         d = new QGpgME::DN::Private(*d);
         d->ref();
         d_save->unref();
     }
 }
 
 void QGpgME::DN::append(const Attribute &attr)
 {
     detach();
     d->attributes.push_back(attr);
     d->reorderedAttributes.clear();
 }
 
 QString QGpgME::DN::operator[](const QString &attr) const
 {
     if (!d) {
         return QString();
     }
     const QString attrUpper = attr.toUpper();
     for (QVector<Attribute>::const_iterator it = d->attributes.constBegin();
             it != d->attributes.constEnd(); ++it)
         if ((*it).name() == attrUpper) {
             return (*it).value();
         }
     return QString();
 }
 
 static QVector<QGpgME::DN::Attribute> empty;
 
 QGpgME::DN::const_iterator QGpgME::DN::begin() const
 {
     return d ? d->attributes.constBegin() : empty.constBegin();
 }
 
 QGpgME::DN::const_iterator QGpgME::DN::end() const
 {
     return d ? d->attributes.constEnd() : empty.constEnd();
 }
 
 void QGpgME::DN::setAttributeOrder (const QStringList &order) const
 {
     d->order = order;
 }
 
 const QStringList & QGpgME::DN::attributeOrder () const
 {
     return d->order;
 }
diff --git a/lang/qt/src/multideletejob.cpp b/lang/qt/src/multideletejob.cpp
index 67f2a78e..c3e6520d 100644
--- a/lang/qt/src/multideletejob.cpp
+++ b/lang/qt/src/multideletejob.cpp
@@ -1,117 +1,117 @@
 /*
     multideletejob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "multideletejob.h"
 #include "protocol.h"
 #include "deletejob.h"
 
 #include <key.h>
 #include <context.h>
 #include <data.h>
 
 #include <iterator>
 
 #include <assert.h>
 
 QGpgME::MultiDeleteJob::MultiDeleteJob(const Protocol *protocol)
-    : Job(0),
+    : Job(nullptr),
       mProtocol(protocol),
-      mJob(0)
+      mJob(nullptr)
 {
     assert(protocol);
 }
 
 QGpgME::MultiDeleteJob::~MultiDeleteJob()
 {
 
 }
 
 GpgME::Error QGpgME::MultiDeleteJob::start(const std::vector<GpgME::Key> &keys, bool allowSecretKeyDeletion)
 {
     mKeys = keys;
     mAllowSecretKeyDeletion = allowSecretKeyDeletion;
     mIt = mKeys.begin();
 
     const GpgME::Error err = startAJob();
 
     if (err) {
         deleteLater();
     }
     return err;
 }
 
 void QGpgME::MultiDeleteJob::slotCancel()
 {
     if (mJob) {
         mJob->slotCancel();
     }
     mIt = mKeys.end();
 }
 
 void QGpgME::MultiDeleteJob::slotResult(const GpgME::Error &err)
 {
-    mJob = 0;
+    mJob = nullptr;
     GpgME::Error error = err;
     if (error ||  // error in last op
             mIt == mKeys.end() || // (shouldn't happen)
             ++mIt == mKeys.end() || // was the last key
             (error = startAJob())) {  // error starting the job for the new key
         Q_EMIT done();
         Q_EMIT result(error, error && mIt != mKeys.end() ? *mIt : GpgME::Key::null);
         deleteLater();
         return;
     }
 
     const int current = mIt - mKeys.begin();
     const int total = mKeys.size();
     Q_EMIT progress(QStringLiteral("%1/%2").arg(current).arg(total), current, total);
 }
 
 GpgME::Error QGpgME::MultiDeleteJob::startAJob()
 {
     if (mIt == mKeys.end()) {
         return GpgME::Error(0);
     }
     mJob = mProtocol->deleteJob();
     assert(mJob);   // FIXME: we need a way to generate errors ourselves,
     // but I don't like the dependency on gpg-error :/
 
     connect(mJob.data(), &DeleteJob::result, this, &MultiDeleteJob::slotResult);
 
     return mJob->start(*mIt, mAllowSecretKeyDeletion);
 }
 
 #include "multideletejob.moc"
diff --git a/lang/qt/src/protocol_p.h b/lang/qt/src/protocol_p.h
index b6d1abfa..57c1ed81 100644
--- a/lang/qt/src/protocol_p.h
+++ b/lang/qt/src/protocol_p.h
@@ -1,433 +1,433 @@
 /*
     protocol_p.h
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 #ifndef __QGPGME_PROTOCOL_P_H__
 #define __QGPGME_PROTOCOL_P_H__
 #include "qgpgmenewcryptoconfig.h"
 
 #include "qgpgmekeygenerationjob.h"
 #include "qgpgmekeylistjob.h"
 #include "qgpgmelistallkeysjob.h"
 #include "qgpgmedecryptjob.h"
 #include "qgpgmedecryptverifyjob.h"
 #include "qgpgmerefreshkeysjob.h"
 #include "qgpgmedeletejob.h"
 #include "qgpgmesecretkeyexportjob.h"
 #include "qgpgmedownloadjob.h"
 #include "qgpgmesignencryptjob.h"
 #include "qgpgmeencryptjob.h"
 #include "qgpgmesignjob.h"
 #include "qgpgmesignkeyjob.h"
 #include "qgpgmeexportjob.h"
 #include "qgpgmeverifydetachedjob.h"
 #include "qgpgmeimportjob.h"
 #include "qgpgmeimportfromkeyserverjob.h"
 #include "qgpgmeverifyopaquejob.h"
 #include "qgpgmechangeexpiryjob.h"
 #include "qgpgmechangeownertrustjob.h"
 #include "qgpgmechangepasswdjob.h"
 #include "qgpgmeadduseridjob.h"
 #include "qgpgmekeyformailboxjob.h"
 #include "qgpgmewkspublishjob.h"
 #include "qgpgmetofupolicyjob.h"
 #include "qgpgmequickjob.h"
 
 namespace
 {
 
 class Protocol : public QGpgME::Protocol
 {
     GpgME::Protocol mProtocol;
 public:
     explicit Protocol(GpgME::Protocol proto) : mProtocol(proto) {}
 
     QString name() const Q_DECL_OVERRIDE
     {
         switch (mProtocol) {
         case GpgME::OpenPGP: return QStringLiteral("OpenPGP");
         case GpgME::CMS:     return QStringLiteral("SMIME");
         default:             return QString();
         }
     }
 
     QString displayName() const Q_DECL_OVERRIDE
     {
         // ah (2.4.16): Where is this used and isn't this inverted
         // with name
         switch (mProtocol) {
         case GpgME::OpenPGP: return QStringLiteral("gpg");
         case GpgME::CMS:     return QStringLiteral("gpgsm");
         default:             return QStringLiteral("unknown");
         }
     }
 
     QGpgME::SpecialJob *specialJob(const char *, const QMap<QString, QVariant> &) const Q_DECL_OVERRIDE
     {
-        return 0;
+        return nullptr;
     }
 
     QGpgME::KeyListJob *keyListJob(bool remote, bool includeSigs, bool validate) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         unsigned int mode = context->keyListMode();
         if (remote) {
             mode |= GpgME::Extern;
             mode &= ~GpgME::Local;
         } else {
             mode |= GpgME::Local;
             mode &= ~GpgME::Extern;
         }
         if (includeSigs) {
             mode |= GpgME::Signatures;
         }
         if (validate) {
             mode |= GpgME::Validate;
         }
         context->setKeyListMode(mode);
         return new QGpgME::QGpgMEKeyListJob(context);
     }
 
     QGpgME::ListAllKeysJob *listAllKeysJob(bool includeSigs, bool validate) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         unsigned int mode = context->keyListMode();
         mode |= GpgME::Local;
         mode &= ~GpgME::Extern;
         if (includeSigs) {
             mode |= GpgME::Signatures;
         }
         if (validate) {
             mode |= GpgME::Validate;
             /* Setting the context to offline mode disables CRL / OCSP checks in
                this Job. Otherwise we would try to fetch the CRL's for all CMS
                keys in the users keyring because GpgME::Validate includes remote
                resources by default in the validity check.
                This setting only has any effect if gpgsm >= 2.1.6 is used.
                */
             context->setOffline(true);
         }
         context->setKeyListMode(mode);
         return new QGpgME::QGpgMEListAllKeysJob(context);
     }
 
     QGpgME::EncryptJob *encryptJob(bool armor, bool textmode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setArmor(armor);
         context->setTextMode(textmode);
         return new QGpgME::QGpgMEEncryptJob(context);
     }
 
     QGpgME::DecryptJob *decryptJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEDecryptJob(context);
     }
 
     QGpgME::SignJob *signJob(bool armor, bool textMode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setArmor(armor);
         context->setTextMode(textMode);
         return new QGpgME::QGpgMESignJob(context);
     }
 
     QGpgME::VerifyDetachedJob *verifyDetachedJob(bool textMode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setTextMode(textMode);
         return new QGpgME::QGpgMEVerifyDetachedJob(context);
     }
 
     QGpgME::VerifyOpaqueJob *verifyOpaqueJob(bool textMode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setTextMode(textMode);
         return new QGpgME::QGpgMEVerifyOpaqueJob(context);
     }
 
     QGpgME::KeyGenerationJob *keyGenerationJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEKeyGenerationJob(context);
     }
 
     QGpgME::ImportJob *importJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEImportJob(context);
     }
 
     QGpgME::ImportFromKeyserverJob *importFromKeyserverJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEImportFromKeyserverJob(context);
     }
 
     QGpgME::ExportJob *publicKeyExportJob(bool armor) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setArmor(armor);
         return new QGpgME::QGpgMEExportJob(context);
     }
 
     QGpgME::ExportJob *secretKeyExportJob(bool armor, const QString &charset) const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::CMS) { // fixme: add support for gpg, too
-            return 0;
+            return nullptr;
         }
 
         // this operation is not supported by gpgme, so we have to call gpgsm ourselves:
         return new QGpgME::QGpgMESecretKeyExportJob(armor, charset);
     }
 
     QGpgME::RefreshKeysJob *refreshKeysJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::CMS) { // fixme: add support for gpg, too
-            return 0;
+            return nullptr;
         }
 
         // this operation is not supported by gpgme, so we have to call gpgsm ourselves:
         return new QGpgME::QGpgMERefreshKeysJob();
     }
 
     QGpgME::DownloadJob *downloadJob(bool armor) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setArmor(armor);
         // this is the hackish interface for downloading from keyserers currently:
         context->setKeyListMode(GpgME::Extern);
         return new QGpgME::QGpgMEDownloadJob(context);
     }
 
     QGpgME::DeleteJob *deleteJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEDeleteJob(context);
     }
 
     QGpgME::SignEncryptJob *signEncryptJob(bool armor, bool textMode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setArmor(armor);
         context->setTextMode(textMode);
         return new QGpgME::QGpgMESignEncryptJob(context);
     }
 
     QGpgME::DecryptVerifyJob *decryptVerifyJob(bool textMode) const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
 
         context->setTextMode(textMode);
         return new QGpgME::QGpgMEDecryptVerifyJob(context);
     }
 
     QGpgME::ChangeExpiryJob *changeExpiryJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return 0;    // only supported by gpg
+            return nullptr;    // only supported by gpg
         }
 
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEChangeExpiryJob(context);
     }
 
     QGpgME::ChangePasswdJob *changePasswdJob() const Q_DECL_OVERRIDE
     {
         if (!GpgME::hasFeature(GpgME::PasswdFeature, 0)) {
-            return 0;
+            return nullptr;
         }
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEChangePasswdJob(context);
     }
 
     QGpgME::SignKeyJob *signKeyJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return 0;    // only supported by gpg
+            return nullptr;    // only supported by gpg
         }
 
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMESignKeyJob(context);
     }
 
     QGpgME::ChangeOwnerTrustJob *changeOwnerTrustJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return 0;    // only supported by gpg
+            return nullptr;    // only supported by gpg
         }
 
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEChangeOwnerTrustJob(context);
     }
 
     QGpgME::AddUserIDJob *addUserIDJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return 0;    // only supported by gpg
+            return nullptr;    // only supported by gpg
         }
 
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return 0;
+            return nullptr;
         }
         return new QGpgME::QGpgMEAddUserIDJob(context);
     }
 
     QGpgME::KeyListJob *locateKeysJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         context->setKeyListMode(GpgME::Extern | GpgME::Local | GpgME::Signatures | GpgME::Validate);
         return new QGpgME::QGpgMEKeyListJob(context);
     }
 
     QGpgME::KeyForMailboxJob *keyForMailboxJob() const Q_DECL_OVERRIDE
     {
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         return new QGpgME::QGpgMEKeyForMailboxJob(context);
     }
 
     QGpgME::WKSPublishJob *wksPublishJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         auto context = GpgME::Context::createForEngine(GpgME::SpawnEngine);
         if (!context) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         return new QGpgME::QGpgMEWKSPublishJob(context.release());
     }
 
     QGpgME::TofuPolicyJob *tofuPolicyJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         return new QGpgME::QGpgMETofuPolicyJob(context);
     }
 
     QGpgME::QuickJob *quickJob() const Q_DECL_OVERRIDE
     {
         if (mProtocol != GpgME::OpenPGP) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol);
         if (!context) {
-            return Q_NULLPTR;
+            return nullptr;
         }
         return new QGpgME::QGpgMEQuickJob(context);
     }
 };
 
 }
 #endif
diff --git a/lang/qt/src/qgpgmebackend.cpp b/lang/qt/src/qgpgmebackend.cpp
index 89f7b559..f7393f09 100644
--- a/lang/qt/src/qgpgmebackend.cpp
+++ b/lang/qt/src/qgpgmebackend.cpp
@@ -1,208 +1,208 @@
 /*
     qgpgmebackend.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmebackend.h"
 
 
 #include "error.h"
 #include "engineinfo.h"
 
 #include "protocol_p.h"
 
 #include <QFile>
 #include <QString>
 
 const char QGpgME::QGpgMEBackend::OpenPGP[] = "OpenPGP";
 const char QGpgME::QGpgMEBackend::SMIME[] = "SMIME";
 
 
 QGpgME::QGpgMEBackend::QGpgMEBackend()
-    : mCryptoConfig(0),
-      mOpenPGPProtocol(0),
-      mSMIMEProtocol(0)
+    : mCryptoConfig(nullptr),
+      mOpenPGPProtocol(nullptr),
+      mSMIMEProtocol(nullptr)
 {
     GpgME::initializeLibrary();
 }
 
 QGpgME::QGpgMEBackend::~QGpgMEBackend()
 {
-    delete mCryptoConfig; mCryptoConfig = 0;
-    delete mOpenPGPProtocol; mOpenPGPProtocol = 0;
-    delete mSMIMEProtocol; mSMIMEProtocol = 0;
+    delete mCryptoConfig; mCryptoConfig = nullptr;
+    delete mOpenPGPProtocol; mOpenPGPProtocol = nullptr;
+    delete mSMIMEProtocol; mSMIMEProtocol = nullptr;
 }
 
 QString QGpgME::QGpgMEBackend::name() const
 {
     return QStringLiteral("gpgme");
 }
 
 QString QGpgME::QGpgMEBackend::displayName() const
 {
     return QStringLiteral("GpgME");
 }
 
 QGpgME::CryptoConfig *QGpgME::QGpgMEBackend::config() const
 {
     if (!mCryptoConfig) {
         if (GpgME::hasFeature(GpgME::GpgConfEngineFeature, 0)) {
             mCryptoConfig = new QGpgMENewCryptoConfig;
         }
     }
     return mCryptoConfig;
 }
 
 static bool check(GpgME::Protocol proto, QString *reason)
 {
     if (!GpgME::checkEngine(proto)) {
         return true;
     }
     if (!reason) {
         return false;
     }
     // error, check why:
 #if 0
 Port away from localised string or delete.
     const GpgME::EngineInfo ei = GpgME::engineInfo(proto);
     if (ei.isNull()) {
         *reason = i18n("GPGME was compiled without support for %1.", proto == GpgME::CMS ? QLatin1String("S/MIME") : QLatin1String("OpenPGP"));
     } else if (ei.fileName() && !ei.version()) {
         *reason = i18n("Engine %1 is not installed properly.", QFile::decodeName(ei.fileName()));
     } else if (ei.fileName() && ei.version() && ei.requiredVersion())
         *reason = i18n("Engine %1 version %2 installed, "
                        "but at least version %3 is required.",
                        QFile::decodeName(ei.fileName()), QLatin1String(ei.version()), QLatin1String(ei.requiredVersion()));
     else {
         *reason = i18n("Unknown problem with engine for protocol %1.", proto == GpgME::CMS ? QLatin1String("S/MIME") : QLatin1String("OpenPGP"));
     }
 #endif
     return false;
 }
 
 bool QGpgME::QGpgMEBackend::checkForOpenPGP(QString *reason) const
 {
     return check(GpgME::OpenPGP, reason);
 }
 
 bool QGpgME::QGpgMEBackend::checkForSMIME(QString *reason) const
 {
     return check(GpgME::CMS, reason);
 }
 
 bool QGpgME::QGpgMEBackend::checkForProtocol(const char *name, QString *reason) const
 {
     if (qstricmp(name, OpenPGP) == 0) {
         return check(GpgME::OpenPGP, reason);
     }
     if (qstricmp(name, SMIME) == 0) {
         return check(GpgME::CMS, reason);
     }
     if (reason) {
         *reason = QStringLiteral("Unsupported protocol \"%1\"").arg(QLatin1String(name));
     }
     return false;
 }
 
 QGpgME::Protocol *QGpgME::QGpgMEBackend::openpgp() const
 {
     if (!mOpenPGPProtocol)
         if (checkForOpenPGP()) {
             mOpenPGPProtocol = new ::Protocol(GpgME::OpenPGP);
         }
     return mOpenPGPProtocol;
 }
 
 QGpgME::Protocol *QGpgME::QGpgMEBackend::smime() const
 {
     if (!mSMIMEProtocol)
         if (checkForSMIME()) {
             mSMIMEProtocol = new ::Protocol(GpgME::CMS);
         }
     return mSMIMEProtocol;
 }
 
 QGpgME::Protocol *QGpgME::QGpgMEBackend::protocol(const char *name) const
 {
     if (qstricmp(name, OpenPGP) == 0) {
         return openpgp();
     }
     if (qstricmp(name, SMIME) == 0) {
         return smime();
     }
-    return 0;
+    return nullptr;
 }
 
 bool QGpgME::QGpgMEBackend::supportsProtocol(const char *name) const
 {
     return qstricmp(name, OpenPGP) == 0 || qstricmp(name, SMIME) == 0;
 }
 
 const char *QGpgME::QGpgMEBackend::enumerateProtocols(int i) const
 {
     switch (i) {
     case 0: return OpenPGP;
     case 1: return SMIME;
-    default: return 0;
+    default: return nullptr;
     }
 }
 
 static QGpgME::QGpgMEBackend *gpgmeBackend;
 
 QGpgME::CryptoConfig *QGpgME::cryptoConfig()
 {
     if (!gpgmeBackend) {
         gpgmeBackend = new QGpgME::QGpgMEBackend();
     }
     return gpgmeBackend->config();
 
 }
 
 QGpgME::Protocol *QGpgME::openpgp()
 {
     if (!gpgmeBackend) {
         gpgmeBackend = new QGpgME::QGpgMEBackend();
     }
     return gpgmeBackend->openpgp();
 }
 
 QGpgME::Protocol *QGpgME::smime()
 {
     if (!gpgmeBackend) {
         gpgmeBackend = new QGpgME::QGpgMEBackend();
     }
     return gpgmeBackend->smime();
 }
diff --git a/lang/qt/src/qgpgmedecryptjob.cpp b/lang/qt/src/qgpgmedecryptjob.cpp
index 598e22fb..c33a4b5f 100644
--- a/lang/qt/src/qgpgmedecryptjob.cpp
+++ b/lang/qt/src/qgpgmedecryptjob.cpp
@@ -1,133 +1,133 @@
 /*
     qgpgmedecryptjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmedecryptjob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "decryptionresult.h"
 #include "data.h"
 
 #include <QBuffer>
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEDecryptJob::QGpgMEDecryptJob(Context *context)
     : mixin_type(context)
 {
     lateInitialization();
 }
 
 QGpgMEDecryptJob::~QGpgMEDecryptJob() {}
 
 static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread,
                                              const std::weak_ptr<QIODevice> &cipherText_,
                                              const std::weak_ptr<QIODevice> &plainText_)
 {
 
     const std::shared_ptr<QIODevice> cipherText = cipherText_.lock();
     const std::shared_ptr<QIODevice> plainText = plainText_.lock();
 
     const _detail::ToThreadMover ctMover(cipherText, thread);
     const _detail::ToThreadMover ptMover(plainText,  thread);
 
     QGpgME::QIODeviceDataProvider in(cipherText);
     const Data indata(&in);
 
     if (!plainText) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         const DecryptionResult res = ctx->decrypt(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(plainText);
         Data outdata(&out);
 
         const DecryptionResult res = ctx->decrypt(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMEDecryptJob::result_type decrypt_qba(Context *ctx, const QByteArray &cipherText)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(cipherText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return decrypt(ctx, 0, buffer, std::shared_ptr<QIODevice>());
+    return decrypt(ctx, nullptr, buffer, std::shared_ptr<QIODevice>());
 }
 
 Error QGpgMEDecryptJob::start(const QByteArray &cipherText)
 {
     run(std::bind(&decrypt_qba, std::placeholders::_1, cipherText));
     return Error();
 }
 
 void QGpgMEDecryptJob::start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText)
 {
     run(std::bind(&decrypt, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), cipherText, plainText);
 }
 
 GpgME::DecryptionResult QGpgME::QGpgMEDecryptJob::exec(const QByteArray &cipherText,
         QByteArray &plainText)
 {
     const result_type r = decrypt_qba(context(), cipherText);
     plainText = std::get<1>(r);
     resultHook(r);
     return mResult;
 }
 
 //PENDING(marc) implement showErrorDialog()
 
 void QGpgMEDecryptJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
 }
 
 #include "qgpgmedecryptjob.moc"
diff --git a/lang/qt/src/qgpgmedecryptverifyjob.cpp b/lang/qt/src/qgpgmedecryptverifyjob.cpp
index 01cf2478..9b3f73db 100644
--- a/lang/qt/src/qgpgmedecryptverifyjob.cpp
+++ b/lang/qt/src/qgpgmedecryptverifyjob.cpp
@@ -1,140 +1,140 @@
 /*
     qgpgmedecryptverifyjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmedecryptverifyjob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "decryptionresult.h"
 #include "verificationresult.h"
 #include "data.h"
 
 #include <QDebug>
 #include "gpgme_backend_debug.h"
 
 #include <QBuffer>
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEDecryptVerifyJob::QGpgMEDecryptVerifyJob(Context *context)
     : mixin_type(context)
 {
     lateInitialization();
 }
 
 QGpgMEDecryptVerifyJob::~QGpgMEDecryptVerifyJob() {}
 
 static QGpgMEDecryptVerifyJob::result_type decrypt_verify(Context *ctx, QThread *thread,
                                                           const std::weak_ptr<QIODevice> &cipherText_,
                                                           const std::weak_ptr<QIODevice> &plainText_)
 {
 
     qCDebug(GPGPME_BACKEND_LOG);
 
     const std::shared_ptr<QIODevice> cipherText = cipherText_.lock();
     const std::shared_ptr<QIODevice> plainText = plainText_.lock();
 
     const _detail::ToThreadMover ctMover(cipherText, thread);
     const _detail::ToThreadMover ptMover(plainText,  thread);
 
     QGpgME::QIODeviceDataProvider in(cipherText);
     const Data indata(&in);
 
     if (!plainText) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         const std::pair<DecryptionResult, VerificationResult> res = ctx->decryptAndVerify(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         qCDebug(GPGPME_BACKEND_LOG) << "End no plainText. Error: " << ae;
         return std::make_tuple(res.first, res.second, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(plainText);
         Data outdata(&out);
 
         const std::pair<DecryptionResult, VerificationResult> res = ctx->decryptAndVerify(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         qCDebug(GPGPME_BACKEND_LOG) << "End plainText. Error: " << ae;
         return std::make_tuple(res.first, res.second, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMEDecryptVerifyJob::result_type decrypt_verify_qba(Context *ctx, const QByteArray &cipherText)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(cipherText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return decrypt_verify(ctx, 0, buffer, std::shared_ptr<QIODevice>());
+    return decrypt_verify(ctx, nullptr, buffer, std::shared_ptr<QIODevice>());
 }
 
 Error QGpgMEDecryptVerifyJob::start(const QByteArray &cipherText)
 {
     run(std::bind(&decrypt_verify_qba, std::placeholders::_1, cipherText));
     return Error();
 }
 
 void QGpgMEDecryptVerifyJob::start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText)
 {
     run(std::bind(&decrypt_verify, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), cipherText, plainText);
 }
 
 std::pair<GpgME::DecryptionResult, GpgME::VerificationResult>
 QGpgME::QGpgMEDecryptVerifyJob::exec(const QByteArray &cipherText, QByteArray &plainText)
 {
     const result_type r = decrypt_verify_qba(context(), cipherText);
     plainText = std::get<2>(r);
     resultHook(r);
     return mResult;
 }
 
 //PENDING(marc) implement showErrorDialog()
 
 void QGpgMEDecryptVerifyJob::resultHook(const result_type &tuple)
 {
     mResult = std::make_pair(std::get<0>(tuple), std::get<1>(tuple));
 }
 #include "qgpgmedecryptverifyjob.moc"
diff --git a/lang/qt/src/qgpgmeencryptjob.cpp b/lang/qt/src/qgpgmeencryptjob.cpp
index aacec297..8fb3dd3f 100644
--- a/lang/qt/src/qgpgmeencryptjob.cpp
+++ b/lang/qt/src/qgpgmeencryptjob.cpp
@@ -1,175 +1,175 @@
 /*
     qgpgmeencryptjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmeencryptjob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "encryptionresult.h"
 #include "data.h"
 
 #include <QBuffer>
 
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEEncryptJob::QGpgMEEncryptJob(Context *context)
     : mixin_type(context),
       mOutputIsBase64Encoded(false)
 {
     lateInitialization();
 }
 
 QGpgMEEncryptJob::~QGpgMEEncryptJob() {}
 
 void QGpgMEEncryptJob::setOutputIsBase64Encoded(bool on)
 {
     mOutputIsBase64Encoded = on;
 }
 
 static QGpgMEEncryptJob::result_type encrypt(Context *ctx, QThread *thread,
         const std::vector<Key> &recipients,
         const std::weak_ptr<QIODevice> &plainText_,
         const std::weak_ptr<QIODevice> &cipherText_,
         const Context::EncryptionFlags eflags,
         bool outputIsBsse64Encoded)
 {
 
     const std::shared_ptr<QIODevice> plainText = plainText_.lock();
     const std::shared_ptr<QIODevice> cipherText = cipherText_.lock();
 
     const _detail::ToThreadMover ctMover(cipherText, thread);
     const _detail::ToThreadMover ptMover(plainText,  thread);
 
     QGpgME::QIODeviceDataProvider in(plainText);
     const Data indata(&in);
 
     if (!cipherText) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const EncryptionResult res = ctx->encrypt(recipients, indata, outdata, eflags);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(cipherText);
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const EncryptionResult res = ctx->encrypt(recipients, indata, outdata, eflags);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMEEncryptJob::result_type encrypt_qba(Context *ctx, const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(plainText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return encrypt(ctx, 0, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
+    return encrypt(ctx, nullptr, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
 }
 
 Error QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust)
 {
     run(std::bind(&encrypt_qba, std::placeholders::_1, recipients, plainText,
                   alwaysTrust ? Context::AlwaysTrust : Context::None, mOutputIsBase64Encoded));
     return Error();
 }
 
 void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText,
                              const std::shared_ptr<QIODevice> &cipherText, const Context::EncryptionFlags eflags)
 {
     run(std::bind(&encrypt,
                     std::placeholders::_1, std::placeholders::_2,
                     recipients,
                     std::placeholders::_3, std::placeholders::_4,
                     eflags,
                     mOutputIsBase64Encoded),
         plainText, cipherText);
 }
 
 EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText,
                                         const Context::EncryptionFlags eflags, QByteArray &cipherText)
 {
     const result_type r = encrypt_qba(context(), recipients, plainText, eflags, mOutputIsBase64Encoded);
     cipherText = std::get<1>(r);
     resultHook(r);
     return mResult;
 }
 
 void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust)
 {
     return start(recipients, plainText, cipherText, alwaysTrust ? Context::AlwaysTrust : Context::None);
 }
 
 EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
 {
     return exec(recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, cipherText);
 }
 
 void QGpgMEEncryptJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
 }
 
 #if 0
 void QGpgMEEncryptJob::showErrorDialog(QWidget *parent, const QString &caption) const
 {
     if (mResult.error() && !mResult.error().isCanceled()) {
         MessageBox::error(parent, mResult, this, caption);
     }
 }
 #endif
 #include "qgpgmeencryptjob.moc"
diff --git a/lang/qt/src/qgpgmekeylistjob.cpp b/lang/qt/src/qgpgmekeylistjob.cpp
index 891b0bd7..295e612d 100644
--- a/lang/qt/src/qgpgmekeylistjob.cpp
+++ b/lang/qt/src/qgpgmekeylistjob.cpp
@@ -1,177 +1,177 @@
 /*
     qgpgmekeylistjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmekeylistjob.h"
 
 #include "key.h"
 #include "context.h"
 #include "keylistresult.h"
 #include <gpg-error.h>
 
 #include <QStringList>
 
 #include <algorithm>
 
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEKeyListJob::QGpgMEKeyListJob(Context *context)
     : mixin_type(context),
       mResult(), mSecretOnly(false)
 {
     lateInitialization();
 }
 
 QGpgMEKeyListJob::~QGpgMEKeyListJob() {}
 
 static KeyListResult do_list_keys(Context *ctx, const QStringList &pats, std::vector<Key> &keys, bool secretOnly)
 {
 
     const _detail::PatternConverter pc(pats);
 
     if (const Error err = ctx->startKeyListing(pc.patterns(), secretOnly)) {
-        return KeyListResult(0, err);
+        return KeyListResult(nullptr, err);
     }
 
     Error err;
     do {
         keys.push_back(ctx->nextKey(err));
     } while (!err);
 
     keys.pop_back();
 
     const KeyListResult result = ctx->endKeyListing();
     ctx->cancelPendingOperation();
     return result;
 }
 
 static QGpgMEKeyListJob::result_type list_keys(Context *ctx, QStringList pats, bool secretOnly)
 {
     if (pats.size() < 2) {
         std::vector<Key> keys;
         const KeyListResult r = do_list_keys(ctx, pats, keys, secretOnly);
         return std::make_tuple(r, keys, QString(), Error());
     }
 
     // The communication channel between gpgme and gpgsm is limited in
     // the number of patterns that can be transported, but they won't
     // say to how much, so we need to find out ourselves if we get a
     // LINE_TOO_LONG error back...
 
     // We could of course just feed them single patterns, and that would
     // probably be easier, but the performance penalty would currently
     // be noticeable.
 
     unsigned int chunkSize = pats.size();
 retry:
     std::vector<Key> keys;
     keys.reserve(pats.size());
     KeyListResult result;
     do {
         const KeyListResult this_result = do_list_keys(ctx, pats.mid(0, chunkSize), keys, secretOnly);
         if (this_result.error().code() == GPG_ERR_LINE_TOO_LONG) {
             // got LINE_TOO_LONG, try a smaller chunksize:
             chunkSize /= 2;
             if (chunkSize < 1)
                 // chunks smaller than one can't be -> return the error.
             {
                 return std::make_tuple(this_result, keys, QString(), Error());
             } else {
                 goto retry;
             }
         } else if (this_result.error().code() == GPG_ERR_EOF) {
             // early end of keylisting (can happen when ~/.gnupg doesn't
             // exist). Fakeing an empty result:
             return std::make_tuple(KeyListResult(), std::vector<Key>(), QString(), Error());
         }
         // ok, that seemed to work...
         result.mergeWith(this_result);
         if (result.error().code()) {
             break;
         }
         pats = pats.mid(chunkSize);
     } while (!pats.empty());
     return std::make_tuple(result, keys, QString(), Error());
 }
 
 Error QGpgMEKeyListJob::start(const QStringList &patterns, bool secretOnly)
 {
     mSecretOnly = secretOnly;
     run(std::bind(&list_keys, std::placeholders::_1, patterns, secretOnly));
     return Error();
 }
 
 KeyListResult QGpgMEKeyListJob::exec(const QStringList &patterns, bool secretOnly, std::vector<Key> &keys)
 {
     mSecretOnly = secretOnly;
     const result_type r = list_keys(context(), patterns, secretOnly);
     resultHook(r);
     keys = std::get<1>(r);
     return std::get<0>(r);
 }
 
 void QGpgMEKeyListJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
     Q_FOREACH (const Key &key, std::get<1>(tuple)) {
         Q_EMIT nextKey(key);
     }
 }
 
 void QGpgMEKeyListJob::addMode(KeyListMode mode)
 {
     context()->addKeyListMode(mode);
 }
 #if 0
 void QGpgMEKeyListJob::showErrorDialog(QWidget *parent, const QString &caption) const
 {
     if (!mResult.error() || mResult.error().isCanceled()) {
         return;
     }
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(mResult.error().asString()));
     KMessageBox::error(parent, msg, caption);
 }
 #endif
 #include "qgpgmekeylistjob.moc"
diff --git a/lang/qt/src/qgpgmelistallkeysjob.cpp b/lang/qt/src/qgpgmelistallkeysjob.cpp
index 0ed32ce7..82483f25 100644
--- a/lang/qt/src/qgpgmelistallkeysjob.cpp
+++ b/lang/qt/src/qgpgmelistallkeysjob.cpp
@@ -1,173 +1,173 @@
 /*
     qgpgmelistallkeysjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmelistallkeysjob.h"
 
 #include "key.h"
 #include "context.h"
 #include "keylistresult.h"
 #include <gpg-error.h>
 
 #include <algorithm>
 
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEListAllKeysJob::QGpgMEListAllKeysJob(Context *context)
     : mixin_type(context),
       mResult()
 {
     lateInitialization();
 }
 
 QGpgMEListAllKeysJob::~QGpgMEListAllKeysJob() {}
 
 static KeyListResult do_list_keys(Context *ctx, std::vector<Key> &keys, bool secretOnly)
 {
 
-    const char **pat = 0;
+    const char **pat = nullptr;
     if (const Error err = ctx->startKeyListing(pat, secretOnly)) {
-        return KeyListResult(0, err);
+        return KeyListResult(nullptr, err);
     }
 
     Error err;
     do {
         keys.push_back(ctx->nextKey(err));
     } while (!err);
 
     keys.pop_back();
 
     const KeyListResult result = ctx->endKeyListing();
     ctx->cancelPendingOperation();
     return result;
 }
 
 namespace
 {
 
 template <typename ForwardIterator, typename BinaryPredicate>
 ForwardIterator unique_by_merge(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
 {
     first = std::adjacent_find(first, last, pred);
     if (first == last) {
         return last;
     }
 
     ForwardIterator dest = first;
     dest->mergeWith(*++first);
     while (++first != last)
         if (pred(*dest, *first)) {
             dest->mergeWith(*first);
         } else {
             *++dest = *first;
         }
     return ++dest;
 }
 
 }
 
 static void merge_keys(std::vector<Key> &merged, std::vector<Key> &pub, std::vector<Key> &sec)
 {
     merged.reserve(pub.size() + sec.size());
 
     std::merge(pub.begin(), pub.end(),
                sec.begin(), sec.end(),
                std::back_inserter(merged),
                ByFingerprint<std::less>());
 
     merged.erase(unique_by_merge(merged.begin(), merged.end(), ByFingerprint<std::equal_to>()),
                  merged.end());
 }
 
 static QGpgMEListAllKeysJob::result_type list_keys(Context *ctx, bool mergeKeys)
 {
     std::vector<Key> pub, sec, merged;
     KeyListResult r;
 
     r.mergeWith(do_list_keys(ctx, pub, false));
     std::sort(pub.begin(), pub.end(), ByFingerprint<std::less>());
 
     r.mergeWith(do_list_keys(ctx, sec, true));
     std::sort(sec.begin(), sec.end(), ByFingerprint<std::less>());
 
     if (mergeKeys) {
         merge_keys(merged, pub, sec);
     } else {
         merged.swap(pub);
     }
     return std::make_tuple(r, merged, sec, QString(), Error());
 }
 
 Error QGpgMEListAllKeysJob::start(bool mergeKeys)
 {
     run(std::bind(&list_keys, std::placeholders::_1, mergeKeys));
     return Error();
 }
 
 KeyListResult QGpgMEListAllKeysJob::exec(std::vector<Key> &pub, std::vector<Key> &sec, bool mergeKeys)
 {
     const result_type r = list_keys(context(), mergeKeys);
     resultHook(r);
     pub = std::get<1>(r);
     sec = std::get<2>(r);
     return std::get<0>(r);
 }
 
 void QGpgMEListAllKeysJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
 }
 
 #if 0
 void QGpgMEListAllKeysJob::showErrorDialog(QWidget *parent, const QString &caption) const
 {
     if (!mResult.error() || mResult.error().isCanceled()) {
         return;
     }
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(mResult.error().asString()));
     KMessageBox::error(parent, msg, caption);
 }
 #endif
 #include "qgpgmelistallkeysjob.moc"
diff --git a/lang/qt/src/qgpgmerefreshkeysjob.cpp b/lang/qt/src/qgpgmerefreshkeysjob.cpp
index 1ff26ecc..ae862e04 100644
--- a/lang/qt/src/qgpgmerefreshkeysjob.cpp
+++ b/lang/qt/src/qgpgmerefreshkeysjob.cpp
@@ -1,230 +1,230 @@
 /*
     qgpgmerefreshkeysjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004 Klarävdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #define MAX_CMD_LENGTH 32768
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmerefreshkeysjob.h"
 
 #include <QDebug>
 #include "gpgme_backend_debug.h"
 
 #include "context.h"
 
 #include <QByteArray>
 #include <QStringList>
 
 #include <gpg-error.h>
 
 #include <assert.h>
 
 QGpgME::QGpgMERefreshKeysJob::QGpgMERefreshKeysJob()
-    : RefreshKeysJob(0),
-      mProcess(0),
+    : RefreshKeysJob(nullptr),
+      mProcess(nullptr),
       mError(0)
 {
 
 }
 
 QGpgME::QGpgMERefreshKeysJob::~QGpgMERefreshKeysJob()
 {
 
 }
 
 GpgME::Error QGpgME::QGpgMERefreshKeysJob::start(const QStringList &patterns)
 {
     assert(mPatternsToDo.empty());
 
     mPatternsToDo = patterns;
     if (mPatternsToDo.empty()) {
         mPatternsToDo.push_back(QStringLiteral(" "));    // empty list means all -> mae
     }
     // sure to fail the first
     // startAProcess() guard clause
 
     return startAProcess();
 }
 
 #if MAX_CMD_LENGTH < 65 + 128
 #error MAX_CMD_LENGTH is too low
 #endif
 
 GpgME::Error QGpgME::QGpgMERefreshKeysJob::startAProcess()
 {
     if (mPatternsToDo.empty()) {
         return GpgME::Error();
     }
     // create and start gpgsm process:
     mProcess = new QProcess(this);
     mProcess->setObjectName(QStringLiteral("gpgsm -k --with-validation --force-crl-refresh --enable-crl-checks"));
 
     // FIXME: obbtain the path to gpgsm from gpgme, so we use the same instance.
     mProcess->setProgram(QStringLiteral("gpgsm"));
     QStringList arguments;
     arguments << QStringLiteral("-k")
               << QStringLiteral("--with-validation")
               << QStringLiteral("--force-crl-refresh")
               << QStringLiteral("--enable-crl-checks");
     unsigned int commandLineLength = MAX_CMD_LENGTH;
     commandLineLength -=
         strlen("gpgsm") + 1 + strlen("-k") + 1 +
         strlen("--with-validation") + 1 + strlen("--force-crl-refresh") + 1 +
         strlen("--enable-crl-checks") + 1;
     while (!mPatternsToDo.empty()) {
         const QByteArray pat = mPatternsToDo.front().toUtf8().trimmed();
         const unsigned int patLength = pat.length();
         if (patLength >= commandLineLength) {
             break;
         }
         mPatternsToDo.pop_front();
         if (pat.isEmpty()) {
             continue;
         }
         arguments << QLatin1String(pat);
         commandLineLength -= patLength + 1;
     }
 
     mProcess->setArguments(arguments);
 
     connect(mProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
             SLOT(slotProcessExited(int,QProcess::ExitStatus)));
     connect(mProcess, SIGNAL(readyReadStandardOutput()),
             SLOT(slotStdout()));
     connect(mProcess, &QProcess::readyReadStandardError,
             this, &QGpgMERefreshKeysJob::slotStderr);
 
     mProcess->start();
     if (!mProcess->waitForStarted()) {
         mError = GpgME::Error::fromCode(GPG_ERR_ENOENT, GPG_ERR_SOURCE_GPGSM);   // what else?
         deleteLater();
         return mError;
     } else {
         return GpgME::Error();
     }
 }
 
 void QGpgME::QGpgMERefreshKeysJob::slotCancel()
 {
     if (mProcess) {
         mProcess->kill();
     }
-    mProcess = 0;
+    mProcess = nullptr;
     mError = GpgME::Error::fromCode(GPG_ERR_CANCELED, GPG_ERR_SOURCE_GPGSM);
 }
 
 void QGpgME::QGpgMERefreshKeysJob::slotStatus(QProcess *proc, const QString &type, const QStringList &args)
 {
     if (proc != mProcess) {
         return;
     }
     QStringList::const_iterator it = args.begin();
     bool ok = false;
 
     if (type == QLatin1String("ERROR")) {
 
         if (args.size() < 2) {
             qCDebug(GPGPME_BACKEND_LOG) << "not recognising ERROR with < 2 args!";
             return;
         }
         const int source = (*++it).toInt(&ok);
         if (!ok) {
             qCDebug(GPGPME_BACKEND_LOG) << "expected number for first ERROR arg, got something else";
             return;
         }
         ok = false;
         const int code = (*++it).toInt(&ok);
         if (!ok) {
             qCDebug(GPGPME_BACKEND_LOG) << "expected number for second ERROR arg, got something else";
             return;
         }
         mError = GpgME::Error::fromCode(code, source);
 
     } else if (type == QLatin1String("PROGRESS")) {
 
         if (args.size() < 4) {
             qCDebug(GPGPME_BACKEND_LOG) << "not recognising PROGRESS with < 4 args!";
             return;
         }
         const QString what = *++it;
         ok = false;
         (*++it).toInt(&ok);
         if (!ok) {
             qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"type\", got something else";
             return;
         }
         ok = false;
         const int cur = (*++it).toInt(&ok);
         if (!ok) {
             qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"cur\", got something else";
             return;
         }
         ok = false;
         const int total = (*++it).toInt(&ok);
         if (!ok) {
             qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"total\", got something else";
             return;
         }
         // TODO port
         Q_EMIT progress(QString(), cur, total);
 
     }
 }
 
 void QGpgME::QGpgMERefreshKeysJob::slotStderr()
 {
     // implement? or not?
 }
 
 void QGpgME::QGpgMERefreshKeysJob::slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus)
 {
     if (!mError && !mPatternsToDo.empty()) {
         if (const GpgME::Error err = startAProcess()) {
             mError = err;
         } else {
             return;
         }
     }
 
     Q_EMIT done();
     if (!mError &&
             (exitStatus != QProcess::NormalExit || exitCode != 0)) {
         mError = GpgME::Error::fromCode(GPG_ERR_GENERAL, GPG_ERR_SOURCE_GPGSM);
     }
     Q_EMIT result(mError);
     deleteLater();
 }
 #include "qgpgmerefreshkeysjob.moc"
diff --git a/lang/qt/src/qgpgmesecretkeyexportjob.cpp b/lang/qt/src/qgpgmesecretkeyexportjob.cpp
index 0a410179..d77a50ab 100644
--- a/lang/qt/src/qgpgmesecretkeyexportjob.cpp
+++ b/lang/qt/src/qgpgmesecretkeyexportjob.cpp
@@ -1,147 +1,147 @@
 /*
     qgpgmesecretexportjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004 Klarävdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmesecretkeyexportjob.h"
 
 #include <QDebug>
 #include "gpgme_backend_debug.h"
 
 #include "context.h"
 #include "data.h"
 
 #include <QStringList>
 
 #include <gpg-error.h>
 
 #include <string.h>
 #include <assert.h>
 
 QGpgME::QGpgMESecretKeyExportJob::QGpgMESecretKeyExportJob(bool armour, const QString &charset)
-    : ExportJob(0),
-      mProcess(0),
+    : ExportJob(nullptr),
+      mProcess(nullptr),
       mError(0),
       mArmour(armour),
       mCharset(charset)
 {
 
 }
 
 QGpgME::QGpgMESecretKeyExportJob::~QGpgMESecretKeyExportJob()
 {
 
 }
 
 GpgME::Error QGpgME::QGpgMESecretKeyExportJob::start(const QStringList &patterns)
 {
     assert(mKeyData.isEmpty());
 
     if (patterns.size() != 1 || patterns.front().isEmpty()) {
         deleteLater();
         return mError = GpgME::Error::fromCode(GPG_ERR_INV_VALUE, GPG_ERR_SOURCE_GPGSM);
     }
 
     // create and start gpgsm process:
     mProcess = new QProcess(this);
     mProcess->setObjectName(QStringLiteral("gpgsm --export-secret-key-p12"));
 
     // FIXME: obtain the path to gpgsm from gpgme, so we use the same instance.
     mProcess->setProgram("gpgsm");
     QStringList arguments;
     arguments << QStringLiteral("--export-secret-key-p12");
     if (mArmour) {
         arguments << QStringLiteral("--armor");
     }
     if (!mCharset.isEmpty()) {
         arguments << QStringLiteral("--p12-charset") << mCharset;
     }
     arguments << QLatin1String(patterns.front().toUtf8());
 
     mProcess->setArguments(arguments);
     connect(mProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
             SLOT(slotProcessExited(int,QProcess::ExitStatus)));
     connect(mProcess, &QProcess::readyReadStandardOutput,
             this, &QGpgMESecretKeyExportJob::slotStdout);
     connect(mProcess, &QProcess::readyReadStandardError,
             this, &QGpgMESecretKeyExportJob::slotStderr);
 
     mProcess->start();
     if (!mProcess->waitForStarted()) {
         mError = GpgME::Error::fromCode(GPG_ERR_ENOENT, GPG_ERR_SOURCE_GPGSM);   // what else?
         deleteLater();
         return mError;
     } else {
         return GpgME::Error();
     }
 }
 
 void QGpgME::QGpgMESecretKeyExportJob::slotCancel()
 {
     if (mProcess) {
         mProcess->kill();
     }
-    mProcess = 0;
+    mProcess = nullptr;
     mError = GpgME::Error::fromCode(GPG_ERR_CANCELED, GPG_ERR_SOURCE_GPGSM);
 }
 
 void QGpgME::QGpgMESecretKeyExportJob::slotStdout()
 {
     QString line = QString::fromLocal8Bit(mProcess->readLine());
     if (!line.isEmpty()) {
         return;
     }
     const unsigned int oldlen = mKeyData.size();
     mKeyData.resize(oldlen + line.length());
     memcpy(mKeyData.data() + oldlen, line.toLatin1(), line.length());
 }
 
 void QGpgME::QGpgMESecretKeyExportJob::slotStderr()
 {
     // implement? or not?
 }
 
 void QGpgME::QGpgMESecretKeyExportJob::slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus)
 {
     Q_EMIT done();
     if (!mError &&
             (exitStatus != QProcess::NormalExit || exitCode != 0)) {
         mError = GpgME::Error::fromCode(GPG_ERR_GENERAL, GPG_ERR_SOURCE_GPGSM);
     }
     Q_EMIT result(mError, mKeyData);
     deleteLater();
 }
 #include "qgpgmesecretkeyexportjob.moc"
diff --git a/lang/qt/src/qgpgmesignencryptjob.cpp b/lang/qt/src/qgpgmesignencryptjob.cpp
index bfaf58c9..284c1106 100644
--- a/lang/qt/src/qgpgmesignencryptjob.cpp
+++ b/lang/qt/src/qgpgmesignencryptjob.cpp
@@ -1,176 +1,176 @@
 /*
     qgpgmesignencryptjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmesignencryptjob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "data.h"
 #include "key.h"
 #include "exception.h"
 
 #include <QBuffer>
 
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMESignEncryptJob::QGpgMESignEncryptJob(Context *context)
     : mixin_type(context),
       mOutputIsBase64Encoded(false)
 {
     lateInitialization();
 }
 
 QGpgMESignEncryptJob::~QGpgMESignEncryptJob() {}
 
 void QGpgMESignEncryptJob::setOutputIsBase64Encoded(bool on)
 {
     mOutputIsBase64Encoded = on;
 }
 
 static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thread, const std::vector<Key> &signers,
                                                       const std::vector<Key> &recipients, const std::weak_ptr<QIODevice> &plainText_,
                                                       const std::weak_ptr<QIODevice> &cipherText_, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
 {
     const std::shared_ptr<QIODevice> &plainText = plainText_.lock();
     const std::shared_ptr<QIODevice> &cipherText = cipherText_.lock();
 
     const _detail::ToThreadMover ctMover(cipherText, thread);
     const _detail::ToThreadMover ptMover(plainText, thread);
 
     QGpgME::QIODeviceDataProvider in(plainText);
     const Data indata(&in);
 
     ctx->clearSigningKeys();
     Q_FOREACH (const Key &signer, signers)
         if (!signer.isNull())
             if (const Error err = ctx->addSigningKey(signer)) {
                 return std::make_tuple(SigningResult(err), EncryptionResult(), QByteArray(), QString(), Error());
             }
 
     if (!cipherText) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const std::pair<SigningResult, EncryptionResult> res = ctx->signAndEncrypt(recipients, indata, outdata, eflags);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res.first, res.second, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(cipherText);
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const std::pair<SigningResult, EncryptionResult> res = ctx->signAndEncrypt(recipients, indata, outdata, eflags);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res.first, res.second, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMESignEncryptJob::result_type sign_encrypt_qba(Context *ctx, const std::vector<Key> &signers,
                                                           const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(plainText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return sign_encrypt(ctx, 0, signers, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
+    return sign_encrypt(ctx, nullptr, signers, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
 }
 
 Error QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust)
 {
     run(std::bind(&sign_encrypt_qba, std::placeholders::_1, signers, recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, mOutputIsBase64Encoded));
     return Error();
 }
 
 void QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients,
                                  const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, const Context::EncryptionFlags eflags)
 {
     run(std::bind(&sign_encrypt, std::placeholders::_1, std::placeholders::_2, signers, recipients, std::placeholders::_3, std::placeholders::_4, eflags, mOutputIsBase64Encoded), plainText, cipherText);
 }
 
 void QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust)
 {
     return start(signers, recipients, plainText, cipherText, alwaysTrust ? Context::AlwaysTrust : Context::None);
 }
 
 std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, QByteArray &cipherText)
 {
     const result_type r = sign_encrypt_qba(context(), signers, recipients, plainText, eflags, mOutputIsBase64Encoded);
     cipherText = std::get<2>(r);
     resultHook(r);
     return mResult;
 }
 
 std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
 {
     return exec(signers, recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, cipherText);
 }
 
 
 #if 0
 
 TODO port?
 void QGpgMESignEncryptJob::showErrorDialog(QWidget *parent, const QString &caption) const
 {
     if ((mResult.first.error()  && !mResult.first.error().isCanceled()) ||
             (mResult.second.error() && !mResult.second.error().isCanceled())) {
         MessageBox::error(parent, mResult.first, mResult.second, this, caption);
     }
 }
 #endif
 
 void QGpgMESignEncryptJob::resultHook(const result_type &tuple)
 {
     mResult = std::make_pair(std::get<0>(tuple), std::get<1>(tuple));
 }
 #include "qgpgmesignencryptjob.moc"
diff --git a/lang/qt/src/qgpgmesignjob.cpp b/lang/qt/src/qgpgmesignjob.cpp
index 7e710f39..e89b9457 100644
--- a/lang/qt/src/qgpgmesignjob.cpp
+++ b/lang/qt/src/qgpgmesignjob.cpp
@@ -1,168 +1,168 @@
 /*
     qgpgmesignjob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmesignjob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "signingresult.h"
 #include "data.h"
 
 #include <QBuffer>
 
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMESignJob::QGpgMESignJob(Context *context)
     : mixin_type(context),
       mOutputIsBase64Encoded(false)
 {
     lateInitialization();
 }
 
 QGpgMESignJob::~QGpgMESignJob() {}
 
 void QGpgMESignJob::setOutputIsBase64Encoded(bool on)
 {
     mOutputIsBase64Encoded = on;
 }
 
 static QGpgMESignJob::result_type sign(Context *ctx, QThread *thread,
                                        const std::vector<Key> &signers,
                                        const std::weak_ptr<QIODevice> &plainText_,
                                        const std::weak_ptr<QIODevice> &signature_,
                                        SignatureMode mode,
                                        bool outputIsBsse64Encoded)
 {
 
     const std::shared_ptr<QIODevice> plainText = plainText_.lock();
     const std::shared_ptr<QIODevice> signature = signature_.lock();
 
     const _detail::ToThreadMover ptMover(plainText, thread);
     const _detail::ToThreadMover sgMover(signature, thread);
 
     QGpgME::QIODeviceDataProvider in(plainText);
     const Data indata(&in);
 
     ctx->clearSigningKeys();
     Q_FOREACH (const Key &signer, signers)
         if (!signer.isNull())
             if (const Error err = ctx->addSigningKey(signer)) {
                 return std::make_tuple(SigningResult(err), QByteArray(), QString(), Error());
             }
 
     if (!signature) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const SigningResult res = ctx->sign(indata, outdata, mode);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(signature);
         Data outdata(&out);
 
         if (outputIsBsse64Encoded) {
             outdata.setEncoding(Data::Base64Encoding);
         }
 
         const SigningResult res = ctx->sign(indata, outdata, mode);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMESignJob::result_type sign_qba(Context *ctx,
         const std::vector<Key> &signers,
         const QByteArray &plainText,
         SignatureMode mode,
         bool outputIsBsse64Encoded)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(plainText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return sign(ctx, 0, signers, buffer, std::shared_ptr<QIODevice>(), mode, outputIsBsse64Encoded);
+    return sign(ctx, nullptr, signers, buffer, std::shared_ptr<QIODevice>(), mode, outputIsBsse64Encoded);
 }
 
 Error QGpgMESignJob::start(const std::vector<Key> &signers, const QByteArray &plainText, SignatureMode mode)
 {
     run(std::bind(&sign_qba, std::placeholders::_1, signers, plainText, mode, mOutputIsBase64Encoded));
     return Error();
 }
 
 void QGpgMESignJob::start(const std::vector<Key> &signers, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &signature, SignatureMode mode)
 {
     run(std::bind(&sign, std::placeholders::_1, std::placeholders::_2, signers, std::placeholders::_3, std::placeholders::_4, mode, mOutputIsBase64Encoded), plainText, signature);
 }
 
 SigningResult QGpgMESignJob::exec(const std::vector<Key> &signers, const QByteArray &plainText, SignatureMode mode, QByteArray &signature)
 {
     const result_type r = sign_qba(context(), signers, plainText, mode, mOutputIsBase64Encoded);
     signature = std::get<1>(r);
     resultHook(r);
     return mResult;
 }
 
 void QGpgMESignJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
 }
 
 #if 0
 TODO port
 void QGpgMESignJob::showErrorDialog(QWidget *parent, const QString &caption) const
 {
     if (mResult.error() && !mResult.error().isCanceled()) {
         MessageBox::error(parent, mResult, this, caption);
     }
 }
 #endif
 #include "qgpgmesignjob.moc"
diff --git a/lang/qt/src/qgpgmeverifyopaquejob.cpp b/lang/qt/src/qgpgmeverifyopaquejob.cpp
index bd7636dc..56c0f50e 100644
--- a/lang/qt/src/qgpgmeverifyopaquejob.cpp
+++ b/lang/qt/src/qgpgmeverifyopaquejob.cpp
@@ -1,130 +1,130 @@
 /*
     qgpgmeverifyopaquejob.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "qgpgmeverifyopaquejob.h"
 
 #include "dataprovider.h"
 
 #include "context.h"
 #include "verificationresult.h"
 #include "data.h"
 
 #include <QBuffer>
 
 
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 QGpgMEVerifyOpaqueJob::QGpgMEVerifyOpaqueJob(Context *context)
     : mixin_type(context)
 {
     lateInitialization();
 }
 
 QGpgMEVerifyOpaqueJob::~QGpgMEVerifyOpaqueJob() {}
 
 static QGpgMEVerifyOpaqueJob::result_type verify_opaque(Context *ctx, QThread *thread, const std::weak_ptr<QIODevice> &signedData_, const std::weak_ptr<QIODevice> &plainText_)
 {
 
     const std::shared_ptr<QIODevice> plainText = plainText_.lock();
     const std::shared_ptr<QIODevice> signedData = signedData_.lock();
 
     const _detail::ToThreadMover ptMover(plainText,  thread);
     const _detail::ToThreadMover sdMover(signedData, thread);
 
     QGpgME::QIODeviceDataProvider in(signedData);
     const Data indata(&in);
 
     if (!plainText) {
         QGpgME::QByteArrayDataProvider out;
         Data outdata(&out);
 
         const VerificationResult res = ctx->verifyOpaqueSignature(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(plainText);
         Data outdata(&out);
 
         const VerificationResult res = ctx->verifyOpaqueSignature(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
         return std::make_tuple(res, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMEVerifyOpaqueJob::result_type verify_opaque_qba(Context *ctx, const QByteArray &signedData)
 {
     const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(signedData);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return verify_opaque(ctx, 0, buffer, std::shared_ptr<QIODevice>());
+    return verify_opaque(ctx, nullptr, buffer, std::shared_ptr<QIODevice>());
 }
 
 Error QGpgMEVerifyOpaqueJob::start(const QByteArray &signedData)
 {
     run(std::bind(&verify_opaque_qba, std::placeholders::_1, signedData));
     return Error();
 }
 
 void QGpgMEVerifyOpaqueJob::start(const std::shared_ptr<QIODevice> &signedData, const std::shared_ptr<QIODevice> &plainText)
 {
     run(std::bind(&verify_opaque, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), signedData, plainText);
 }
 
 GpgME::VerificationResult QGpgME::QGpgMEVerifyOpaqueJob::exec(const QByteArray &signedData, QByteArray &plainText)
 {
     const result_type r = verify_opaque_qba(context(), signedData);
     plainText = std::get<1>(r);
     resultHook(r);
     return mResult;
 }
 
 //PENDING(marc) implement showErrorDialog()
 
 void QGpgME::QGpgMEVerifyOpaqueJob::resultHook(const result_type &tuple)
 {
     mResult = std::get<0>(tuple);
 }
 #include "qgpgmeverifyopaquejob.moc"
diff --git a/lang/qt/src/threadedjobmixin.cpp b/lang/qt/src/threadedjobmixin.cpp
index cd7c494f..d5399f7b 100644
--- a/lang/qt/src/threadedjobmixin.cpp
+++ b/lang/qt/src/threadedjobmixin.cpp
@@ -1,189 +1,189 @@
 /*
     threadedjobmixin.cpp
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "threadedjobmixin.h"
 
 #include "dataprovider.h"
 
 #include "data.h"
 
 #include <QString>
 #include <QStringList>
 #include <QByteArray>
 
 
 #include <algorithm>
 #include <iterator>
 
 using namespace QGpgME;
 using namespace GpgME;
 
 #ifdef Q_OS_WIN
 #include <windows.h>
 
 static QString fromEncoding (unsigned int src_encoding, const char *data)
 {
     int n = MultiByteToWideChar(src_encoding, 0, data, -1, NULL, 0);
     if (n < 0) {
         return QString();
     }
 
     wchar_t *result = (wchar_t *) malloc ((n+1) * sizeof *result);
 
     n = MultiByteToWideChar(src_encoding, 0, data, -1, result, n);
     if (n < 0) {
         free(result);
         return QString();
     }
     const auto ret = QString::fromWCharArray(result, n);
     free(result);
     return ret;
 }
 #endif
 
 static QString stringFromGpgOutput(const QByteArray &ba)
 {
 #ifdef Q_OS_WIN
     /* Qt on Windows uses GetACP while GnuPG prefers
      * GetConsoleOutputCP.
      *
      * As we are not a console application GetConsoleOutputCP
      * usually returns 0.
      * From experience the closest thing that let's us guess
      * what GetConsoleOutputCP returns for a console application
      * it appears to be the OEMCP.
      */
     unsigned int cpno = GetConsoleOutputCP ();
     if (!cpno) {
         cpno = GetOEMCP();
     }
     if (!cpno) {
         cpno = GetACP();
     }
     if (!cpno) {
         return QString();
     }
 
     return fromEncoding(cpno, ba.constData());
 #else
     return QString::fromLocal8Bit(ba);
 #endif
 }
 
 static QString markupDiagnostics(const QString &data)
 {
     // First ensure that we don't have html in the diag.
     QString ret = QStringLiteral("<pre>%1</pre>").arg(data.toHtmlEscaped());
 
     return ret;
 }
 
 static const unsigned int CMSAuditLogFlags = Context::AuditLogWithHelp | Context::HtmlAuditLog;
 static const unsigned int OpenPGPAuditLogFlags = Context::DiagnosticAuditLog;
 
 QString _detail::audit_log_as_html(Context *ctx, GpgME::Error &err)
 {
     assert(ctx);
     QGpgME::QByteArrayDataProvider dp;
     Data data(&dp);
     assert(!data.isNull());
 
     if (ctx->protocol() == OpenPGP) {
         if ((err = ctx->getAuditLog(data, OpenPGPAuditLogFlags))) {
             return QString::fromLocal8Bit(err.asString());
         }
         const QByteArray ba = dp.data();
         return markupDiagnostics(stringFromGpgOutput(ba));
     }
 
     if (ctx->protocol() == CMS) {
         if ((err = ctx->lastError()) || (err = ctx->getAuditLog(data, CMSAuditLogFlags))) {
             return QString::fromLocal8Bit(err.asString());
         }
         const QByteArray ba = dp.data();
         return QString::fromUtf8(ba.data(), ba.size());
     }
 
     return QStringLiteral("Unsupported protocol for Audit Log");
 }
 
 static QList<QByteArray> from_sl(const QStringList &sl)
 {
     QList<QByteArray> result;
     Q_FOREACH (const QString &str, sl) {
         result.append(str.toUtf8());
     }
 
 #if 0
     std::transform(sl.begin(), sl.end(), std::back_inserter(result),
                    mem_fn(static_cast<QByteArray()const>(&QString::toUtf8)));
 #endif
     return result;
 }
 
 static QList<QByteArray> single(const QByteArray &ba)
 {
     QList<QByteArray> result;
     result.push_back(ba);
     return result;
 }
 
 _detail::PatternConverter::PatternConverter(const QByteArray &ba)
-    : m_list(single(ba)), m_patterns(0) {}
+    : m_list(single(ba)), m_patterns(nullptr) {}
 _detail::PatternConverter::PatternConverter(const QString &s)
-    : m_list(single(s.toUtf8())), m_patterns(0) {}
+    : m_list(single(s.toUtf8())), m_patterns(nullptr) {}
 _detail::PatternConverter::PatternConverter(const QList<QByteArray> &lba)
-    : m_list(lba), m_patterns(0) {}
+    : m_list(lba), m_patterns(nullptr) {}
 _detail::PatternConverter::PatternConverter(const QStringList &sl)
-    :  m_list(from_sl(sl)), m_patterns(0) {}
+    :  m_list(from_sl(sl)), m_patterns(nullptr) {}
 
 const char **_detail::PatternConverter::patterns() const
 {
     if (!m_patterns) {
         m_patterns = new const char *[ m_list.size() + 1 ];
         const char **end = std::transform(m_list.begin(), m_list.end(), m_patterns,
                                           std::mem_fn(&QByteArray::constData));
-        *end = 0;
+        *end = nullptr;
     }
     return m_patterns;
 }
 
 _detail::PatternConverter::~PatternConverter()
 {
     delete [] m_patterns;
 }
diff --git a/lang/qt/src/threadedjobmixin.h b/lang/qt/src/threadedjobmixin.h
index 32cdb8e6..ef30ab36 100644
--- a/lang/qt/src/threadedjobmixin.h
+++ b/lang/qt/src/threadedjobmixin.h
@@ -1,282 +1,282 @@
 /*
     threadedjobmixin.h
 
     This file is part of qgpgme, the Qt API binding for gpgme
     Copyright (c) 2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifndef __QGPGME_THREADEDJOBMIXING_H__
 #define __QGPGME_THREADEDJOBMIXING_H__
 
 #include <QMutex>
 #include <QMutexLocker>
 #include <QThread>
 #include <QString>
 #include <QIODevice>
 
 #ifdef BUILDING_QGPGME
 # include "context.h"
 # include "interfaces/progressprovider.h"
 #else
 # include <gpgme++/context.h>
 # include <gpgme++/interfaces/progressprovider.h>
 #endif
 
 #include "job.h"
 
 #include <cassert>
 #include <functional>
 
 namespace QGpgME
 {
 namespace _detail
 {
 
 QString audit_log_as_html(GpgME::Context *ctx, GpgME::Error &err);
 
 class PatternConverter
 {
     const QList<QByteArray> m_list;
     mutable const char **m_patterns;
 public:
     explicit PatternConverter(const QByteArray &ba);
     explicit PatternConverter(const QString &s);
     explicit PatternConverter(const QList<QByteArray> &lba);
     explicit PatternConverter(const QStringList &sl);
     ~PatternConverter();
 
     const char **patterns() const;
 };
 
 class ToThreadMover
 {
     QObject *const m_object;
     QThread *const m_thread;
 public:
     ToThreadMover(QObject *o, QThread *t) : m_object(o), m_thread(t) {}
     ToThreadMover(QObject &o, QThread *t) : m_object(&o), m_thread(t) {}
     ToThreadMover(const std::shared_ptr<QObject> &o, QThread *t) : m_object(o.get()), m_thread(t) {}
     ~ToThreadMover()
     {
         if (m_object && m_thread) {
             m_object->moveToThread(m_thread);
         }
     }
 };
 
 template <typename T_result>
 class Thread : public QThread
 {
 public:
     explicit Thread(QObject *parent = Q_NULLPTR) : QThread(parent) {}
 
     void setFunction(const std::function<T_result()> &function)
     {
         const QMutexLocker locker(&m_mutex);
         m_function = function;
     }
 
     T_result result() const
     {
         const QMutexLocker locker(&m_mutex);
         return m_result;
     }
 
 private:
     void run() Q_DECL_OVERRIDE {
         const QMutexLocker locker(&m_mutex);
         m_result = m_function();
     }
 private:
     mutable QMutex m_mutex;
     std::function<T_result()> m_function;
     T_result m_result;
 };
 
 template <typename T_base, typename T_result = std::tuple<GpgME::Error, QString, GpgME::Error> >
 class ThreadedJobMixin : public T_base, public GpgME::ProgressProvider
 {
 public:
     typedef ThreadedJobMixin<T_base, T_result> mixin_type;
     typedef T_result result_type;
 
 protected:
     static_assert(std::tuple_size<T_result>::value > 2,
                   "Result tuple too small");
     static_assert(std::is_same <
                   typename std::tuple_element <
                   std::tuple_size<T_result>::value - 2,
                   T_result
                   >::type,
                   QString
                   >::value,
                   "Second to last result type not a QString");
     static_assert(std::is_same <
                   typename std::tuple_element <
                   std::tuple_size<T_result>::value - 1,
                   T_result
                   >::type,
                   GpgME::Error
                   >::value,
                   "Last result type not a GpgME::Error");
 
     explicit ThreadedJobMixin(GpgME::Context *ctx)
-        : T_base(0), m_ctx(ctx), m_thread(), m_auditLog(), m_auditLogError()
+        : T_base(nullptr), m_ctx(ctx), m_thread(), m_auditLog(), m_auditLogError()
     {
     }
 
     void lateInitialization()
     {
         assert(m_ctx);
         QObject::connect(&m_thread, &QThread::finished, this,
                          &mixin_type::slotFinished);
         m_ctx->setProgressProvider(this);
         QGpgME::g_context_map.insert(this, m_ctx.get());
     }
 
     ~ThreadedJobMixin()
     {
         QGpgME::g_context_map.remove(this);
     }
 
     template <typename T_binder>
     void run(const T_binder &func)
     {
         m_thread.setFunction(std::bind(func, this->context()));
         m_thread.start();
     }
     template <typename T_binder>
     void run(const T_binder &func, const std::shared_ptr<QIODevice> &io)
     {
         if (io) {
             io->moveToThread(&m_thread);
         }
         // the arguments passed here to the functor are stored in a QThread, and are not
         // necessarily destroyed (living outside the UI thread) at the time the result signal
         // is emitted and the signal receiver wants to clean up IO devices.
         // To avoid such races, we pass std::weak_ptr's to the functor.
         m_thread.setFunction(std::bind(func, this->context(), this->thread(), std::weak_ptr<QIODevice>(io)));
         m_thread.start();
     }
     template <typename T_binder>
     void run(const T_binder &func, const std::shared_ptr<QIODevice> &io1, const std::shared_ptr<QIODevice> &io2)
     {
         if (io1) {
             io1->moveToThread(&m_thread);
         }
         if (io2) {
             io2->moveToThread(&m_thread);
         }
         // the arguments passed here to the functor are stored in a QThread, and are not
         // necessarily destroyed (living outside the UI thread) at the time the result signal
         // is emitted and the signal receiver wants to clean up IO devices.
         // To avoid such races, we pass std::weak_ptr's to the functor.
         m_thread.setFunction(std::bind(func, this->context(), this->thread(), std::weak_ptr<QIODevice>(io1), std::weak_ptr<QIODevice>(io2)));
         m_thread.start();
     }
     GpgME::Context *context() const
     {
         return m_ctx.get();
     }
 
     virtual void resultHook(const result_type &) {}
 
     void slotFinished()
     {
         const T_result r = m_thread.result();
         m_auditLog = std::get < std::tuple_size<T_result>::value - 2 > (r);
         m_auditLogError = std::get < std::tuple_size<T_result>::value - 1 > (r);
         resultHook(r);
         Q_EMIT this->done();
         doEmitResult(r);
         this->deleteLater();
     }
     void slotCancel() Q_DECL_OVERRIDE {
         if (m_ctx)
         {
             m_ctx->cancelPendingOperation();
         }
     }
     QString auditLogAsHtml() const Q_DECL_OVERRIDE
     {
         return m_auditLog;
     }
     GpgME::Error auditLogError() const Q_DECL_OVERRIDE
     {
         return m_auditLogError;
     }
     void showProgress(const char * /*what*/,
                       int /*type*/, int current, int total) Q_DECL_OVERRIDE {
         // will be called from the thread exec'ing the operation, so
         // just bounce everything to the owning thread:
         // ### hope this is thread-safe (meta obj is const, and
         // ### portEvent is thread-safe, so should be ok)
         QMetaObject::invokeMethod(this, "progress", Qt::QueuedConnection,
         // TODO port
         Q_ARG(QString, QString()),
         Q_ARG(int, current),
         Q_ARG(int, total));
     }
 private:
     template <typename T1, typename T2>
     void doEmitResult(const std::tuple<T1, T2> &tuple)
     {
         Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple));
     }
 
     template <typename T1, typename T2, typename T3>
     void doEmitResult(const std::tuple<T1, T2, T3> &tuple)
     {
         Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple));
     }
 
     template <typename T1, typename T2, typename T3, typename T4>
     void doEmitResult(const std::tuple<T1, T2, T3, T4> &tuple)
     {
         Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple), std::get<3>(tuple));
     }
 
     template <typename T1, typename T2, typename T3, typename T4, typename T5>
     void doEmitResult(const std::tuple<T1, T2, T3, T4, T5> &tuple)
     {
         Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple), std::get<3>(tuple), std::get<4>(tuple));
     }
 
 private:
     std::shared_ptr<GpgME::Context> m_ctx;
     Thread<T_result> m_thread;
     QString m_auditLog;
     GpgME::Error m_auditLogError;
 };
 
 }
 }
 
 #endif /* __QGPGME_THREADEDJOBMIXING_H__ */