Programmatically apply new formatting to code

Run this:

for i in  **/*.cc **/*.c **/*.h **/*.hh; do
  clang-format < $i >| $i.new && mv $i.new $i
done

1 files changed, 64 insertions, 71 deletions

diff --git a/libqpdf/QPDFCrypto_gnutls.cc b/libqpdf/QPDFCrypto_gnutls.cc
index 8c05f314..86e92c40 100644
--- a/libqpdf/QPDFCrypto_gnutls.cc
+++ b/libqpdf/QPDFCrypto_gnutls.cc
@@ -18,12 +18,10 @@ QPDFCrypto_gnutls::QPDFCrypto_gnutls() :
 
 QPDFCrypto_gnutls::~QPDFCrypto_gnutls()
 {
-    if (this->hash_ctx)
-    {
+    if (this->hash_ctx) {
         gnutls_hash_deinit(this->hash_ctx, digest);
     }
-    if (cipher_ctx)
-    {
+    if (cipher_ctx) {
         gnutls_cipher_deinit(this->cipher_ctx);
     }
     this->aes_key_data = nullptr;
@@ -33,9 +31,8 @@ QPDFCrypto_gnutls::~QPDFCrypto_gnutls()
 void
 QPDFCrypto_gnutls::provideRandomData(unsigned char* data, size_t len)
 {
-    int code = gnutls_rnd (GNUTLS_RND_KEY, data, len);
-    if (code < 0)
-    {
+    int code = gnutls_rnd(GNUTLS_RND_KEY, data, len);
+    if (code < 0) {
         throw std::runtime_error(
             std::string("gnutls: random number generation error: ") +
             std::string(gnutls_strerror(code)));
@@ -47,8 +44,7 @@ QPDFCrypto_gnutls::MD5_init()
 {
     MD5_finalize();
     int code = gnutls_hash_init(&this->hash_ctx, GNUTLS_DIG_MD5);
-    if (code < 0)
-    {
+    if (code < 0) {
         this->hash_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: MD5 error: ") +
@@ -65,8 +61,7 @@ QPDFCrypto_gnutls::MD5_update(unsigned char const* data, size_t len)
 void
 QPDFCrypto_gnutls::MD5_finalize()
 {
-    if (this->hash_ctx)
-    {
+    if (this->hash_ctx) {
         gnutls_hash_deinit(this->hash_ctx, this->digest);
         this->hash_ctx = nullptr;
     }
@@ -82,10 +77,9 @@ void
 QPDFCrypto_gnutls::RC4_init(unsigned char const* key_data, int key_len)
 {
     RC4_finalize();
-    if (key_len == -1)
-    {
-        key_len = QIntC::to_int(
-            strlen(reinterpret_cast<char const*>(key_data)));
+    if (key_len == -1) {
+        key_len =
+            QIntC::to_int(strlen(reinterpret_cast<char const*>(key_data)));
     }
     gnutls_datum_t key;
     key.data = const_cast<unsigned char*>(key_data);
@@ -93,8 +87,7 @@ QPDFCrypto_gnutls::RC4_init(unsigned char const* key_data, int key_len)
 
     int code = gnutls_cipher_init(
         &this->cipher_ctx, GNUTLS_CIPHER_ARCFOUR_128, &key, nullptr);
-    if (code < 0)
-    {
+    if (code < 0) {
         this->cipher_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: RC4 error: ") +
@@ -103,11 +96,10 @@ QPDFCrypto_gnutls::RC4_init(unsigned char const* key_data, int key_len)
 }
 
 void
-QPDFCrypto_gnutls::RC4_process(unsigned char* in_data, size_t len,
-                               unsigned char* out_data)
+QPDFCrypto_gnutls::RC4_process(
+    unsigned char* in_data, size_t len, unsigned char* out_data)
 {
-    if (nullptr == out_data)
-    {
+    if (nullptr == out_data) {
         out_data = in_data;
     }
     gnutls_cipher_encrypt2(this->cipher_ctx, in_data, len, out_data, len);
@@ -116,8 +108,7 @@ QPDFCrypto_gnutls::RC4_process(unsigned char* in_data, size_t len,
 void
 QPDFCrypto_gnutls::RC4_finalize()
 {
-    if (this->cipher_ctx)
-    {
+    if (this->cipher_ctx) {
         gnutls_cipher_deinit(this->cipher_ctx);
         this->cipher_ctx = nullptr;
     }
@@ -128,25 +119,23 @@ QPDFCrypto_gnutls::SHA2_init(int bits)
 {
     SHA2_finalize();
     gnutls_digest_algorithm_t alg = GNUTLS_DIG_UNKNOWN;
-    switch (bits)
-    {
-      case 256:
+    switch (bits) {
+    case 256:
         alg = GNUTLS_DIG_SHA256;
         break;
-      case 384:
+    case 384:
         alg = GNUTLS_DIG_SHA384;
         break;
-      case 512:
+    case 512:
         alg = GNUTLS_DIG_SHA512;
         break;
-      default:
+    default:
         badBits();
         break;
     }
     this->sha2_bits = bits;
     int code = gnutls_hash_init(&this->hash_ctx, alg);
-    if (code < 0)
-    {
+    if (code < 0) {
         this->hash_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: SHA") + QUtil::int_to_string(bits) +
@@ -163,8 +152,7 @@ QPDFCrypto_gnutls::SHA2_update(unsigned char const* data, size_t len)
 void
 QPDFCrypto_gnutls::SHA2_finalize()
 {
-    if (this->hash_ctx)
-    {
+    if (this->hash_ctx) {
         gnutls_hash_deinit(this->hash_ctx, this->digest);
         this->hash_ctx = nullptr;
     }
@@ -174,18 +162,17 @@ std::string
 QPDFCrypto_gnutls::SHA2_digest()
 {
     std::string result;
-    switch (this->sha2_bits)
-    {
-      case 256:
+    switch (this->sha2_bits) {
+    case 256:
         result = std::string(reinterpret_cast<char*>(this->digest), 32);
         break;
-      case 384:
+    case 384:
         result = std::string(reinterpret_cast<char*>(this->digest), 48);
         break;
-      case 512:
+    case 512:
         result = std::string(reinterpret_cast<char*>(this->digest), 64);
         break;
-      default:
+    default:
         badBits();
         break;
     }
@@ -194,14 +181,16 @@ QPDFCrypto_gnutls::SHA2_digest()
 
 void
 QPDFCrypto_gnutls::rijndael_init(
-    bool encrypt, unsigned char const* key_data, size_t key_len,
-    bool cbc_mode, unsigned char* cbc_block)
+    bool encrypt,
+    unsigned char const* key_data,
+    size_t key_len,
+    bool cbc_mode,
+    unsigned char* cbc_block)
 {
     rijndael_finalize();
     this->encrypt = encrypt;
     this->cbc_mode = cbc_mode;
-    if (! cbc_mode)
-    {
+    if (!cbc_mode) {
         // Save the key so we can re-initialize.
         this->aes_key_data = key_data;
         this->aes_key_len = key_len;
@@ -213,18 +202,17 @@ QPDFCrypto_gnutls::rijndael_init(
 
     cipher_key.data = const_cast<unsigned char*>(key_data);
 
-    switch(key_len)
-    {
-      case 16:
+    switch (key_len) {
+    case 16:
         alg = GNUTLS_CIPHER_AES_128_CBC;
         break;
-      case 32:
+    case 32:
         alg = GNUTLS_CIPHER_AES_256_CBC;
         break;
-      case 24:
+    case 24:
         alg = GNUTLS_CIPHER_AES_192_CBC;
         break;
-      default:
+    default:
         alg = GNUTLS_CIPHER_AES_128_CBC;
         break;
     }
@@ -235,8 +223,7 @@ QPDFCrypto_gnutls::rijndael_init(
     iv.size = rijndael_buf_size;
 
     int code = gnutls_cipher_init(&this->cipher_ctx, alg, &cipher_key, &iv);
-    if (code < 0)
-    {
+    if (code < 0) {
         this->cipher_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: AES error: ") +
@@ -245,39 +232,45 @@ QPDFCrypto_gnutls::rijndael_init(
 }
 
 void
-QPDFCrypto_gnutls::rijndael_process(unsigned char* in_data,
-                                    unsigned char* out_data)
+QPDFCrypto_gnutls::rijndael_process(
+    unsigned char* in_data, unsigned char* out_data)
 {
-    if (this->encrypt)
-    {
-        gnutls_cipher_encrypt2(this->cipher_ctx,
-                               in_data, rijndael_buf_size,
-                               out_data, rijndael_buf_size);
-    }
-    else
-    {
-        gnutls_cipher_decrypt2(this->cipher_ctx,
-                               in_data, rijndael_buf_size,
-                               out_data, rijndael_buf_size);
+    if (this->encrypt) {
+        gnutls_cipher_encrypt2(
+            this->cipher_ctx,
+            in_data,
+            rijndael_buf_size,
+            out_data,
+            rijndael_buf_size);
+    } else {
+        gnutls_cipher_decrypt2(
+            this->cipher_ctx,
+            in_data,
+            rijndael_buf_size,
+            out_data,
+            rijndael_buf_size);
     }
 
     // Gnutls doesn't support AES in ECB (non-CBC) mode, but the
     // result is the same as if you just reset the cbc block to all
     // zeroes each time. We jump through a few hoops here to make this
     // work.
-    if (! this->cbc_mode)
-    {
-        static unsigned char zeroes[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-        rijndael_init(this->encrypt, this->aes_key_data, this->aes_key_len,
-                      false, zeroes);
+    if (!this->cbc_mode) {
+        static unsigned char zeroes[16] = {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        rijndael_init(
+            this->encrypt,
+            this->aes_key_data,
+            this->aes_key_len,
+            false,
+            zeroes);
     }
 }
 
 void
 QPDFCrypto_gnutls::rijndael_finalize()
 {
-    if (this->cipher_ctx)
-    {
+    if (this->cipher_ctx) {
         gnutls_cipher_deinit(this->cipher_ctx);
         this->cipher_ctx = nullptr;
     }