clear up unusual ()-ing

diff --git a/ncrypt/cryptglue.c b/ncrypt/cryptglue.c
index b80513538436b4478247a03ecbd465e9c9f64ae1..781298cdad2b0be47162b59c9b3056594261d1bb 100644 (file)
--- a/ncrypt/cryptglue.c
+++ b/ncrypt/cryptglue.c
@@ -75,7 +75,7 @@ extern struct CryptModuleSpecs crypt_mod_smime_gpgme;
 /* Call the function FUNC in the crypto module identified by
  * IDENTIFIER. This may be used as an expression. */
 #define CRYPT_MOD_CALL(identifier, func)                                       \
-  *(crypto_module_lookup(APPLICATION_##identifier))->func
+  (*(crypto_module_lookup(APPLICATION_##identifier))->func)
 
 /**
  * crypt_init - Initialise the crypto backends
@@ -122,10 +122,10 @@ void crypt_init(void)
 #if defined(CRYPT_BACKEND_CLASSIC_PGP) ||                                      \
     defined(CRYPT_BACKEND_CLASSIC_SMIME) || defined(CRYPT_BACKEND_GPGME)
   if (CRYPT_MOD_CALL_CHECK(PGP, init))
-    (CRYPT_MOD_CALL(PGP, init))();
+    CRYPT_MOD_CALL(PGP, init)();
 
   if (CRYPT_MOD_CALL_CHECK(SMIME, init))
-    (CRYPT_MOD_CALL(SMIME, init))();
+    CRYPT_MOD_CALL(SMIME, init)();
 #endif
 }
 
@@ -172,7 +172,7 @@ bool crypt_has_module_backend(int type)
 void crypt_pgp_void_passphrase(void)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, void_passphrase))
-    (CRYPT_MOD_CALL(PGP, void_passphrase))();
+    CRYPT_MOD_CALL(PGP, void_passphrase)();
 }
 
 /**
@@ -181,7 +181,7 @@ void crypt_pgp_void_passphrase(void)
 int crypt_pgp_valid_passphrase(void)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, valid_passphrase))
-    return (CRYPT_MOD_CALL(PGP, valid_passphrase))();
+    return CRYPT_MOD_CALL(PGP, valid_passphrase)();
 
   return 0;
 }
@@ -192,7 +192,7 @@ int crypt_pgp_valid_passphrase(void)
 int crypt_pgp_decrypt_mime(FILE *a, FILE **b, struct Body *c, struct Body **d)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, decrypt_mime))
-    return (CRYPT_MOD_CALL(PGP, decrypt_mime))(a, b, c, d);
+    return CRYPT_MOD_CALL(PGP, decrypt_mime)(a, b, c, d);
 
   return -1;
 }
@@ -203,7 +203,7 @@ int crypt_pgp_decrypt_mime(FILE *a, FILE **b, struct Body *c, struct Body **d)
 int crypt_pgp_application_handler(struct Body *m, struct State *s)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, application_handler))
-    return (CRYPT_MOD_CALL(PGP, application_handler))(m, s);
+    return CRYPT_MOD_CALL(PGP, application_handler)(m, s);
 
   return -1;
 }
@@ -214,7 +214,7 @@ int crypt_pgp_application_handler(struct Body *m, struct State *s)
 int crypt_pgp_encrypted_handler(struct Body *a, struct State *s)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, encrypted_handler))
-    return (CRYPT_MOD_CALL(PGP, encrypted_handler))(a, s);
+    return CRYPT_MOD_CALL(PGP, encrypted_handler)(a, s);
 
   return -1;
 }
@@ -225,7 +225,7 @@ int crypt_pgp_encrypted_handler(struct Body *a, struct State *s)
 void crypt_pgp_invoke_getkeys(struct Address *addr)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_invoke_getkeys))
-    (CRYPT_MOD_CALL(PGP, pgp_invoke_getkeys))(addr);
+    CRYPT_MOD_CALL(PGP, pgp_invoke_getkeys)(addr);
 }
 
 /**
@@ -234,7 +234,7 @@ void crypt_pgp_invoke_getkeys(struct Address *addr)
 int crypt_pgp_check_traditional(FILE *fp, struct Body *b, bool just_one)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_check_traditional))
-    return (CRYPT_MOD_CALL(PGP, pgp_check_traditional))(fp, b, just_one);
+    return CRYPT_MOD_CALL(PGP, pgp_check_traditional)(fp, b, just_one);
 
   return 0;
 }
@@ -245,7 +245,7 @@ int crypt_pgp_check_traditional(FILE *fp, struct Body *b, bool just_one)
 struct Body *crypt_pgp_traditional_encryptsign(struct Body *a, int flags, char *keylist)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_traditional_encryptsign))
-    return (CRYPT_MOD_CALL(PGP, pgp_traditional_encryptsign))(a, flags, keylist);
+    return CRYPT_MOD_CALL(PGP, pgp_traditional_encryptsign)(a, flags, keylist);
 
   return NULL;
 }
@@ -256,7 +256,7 @@ struct Body *crypt_pgp_traditional_encryptsign(struct Body *a, int flags, char *
 struct Body *crypt_pgp_make_key_attachment(void)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_make_key_attachment))
-    return (CRYPT_MOD_CALL(PGP, pgp_make_key_attachment))();
+    return CRYPT_MOD_CALL(PGP, pgp_make_key_attachment)();
 
   return NULL;
 }
@@ -267,7 +267,7 @@ struct Body *crypt_pgp_make_key_attachment(void)
 char *crypt_pgp_find_keys(struct Address *addrlist, bool oppenc_mode)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, find_keys))
-    return (CRYPT_MOD_CALL(PGP, find_keys))(addrlist, oppenc_mode);
+    return CRYPT_MOD_CALL(PGP, find_keys)(addrlist, oppenc_mode);
 
   return NULL;
 }
@@ -278,7 +278,7 @@ char *crypt_pgp_find_keys(struct Address *addrlist, bool oppenc_mode)
 struct Body *crypt_pgp_sign_message(struct Body *a)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, sign_message))
-    return (CRYPT_MOD_CALL(PGP, sign_message))(a);
+    return CRYPT_MOD_CALL(PGP, sign_message)(a);
 
   return NULL;
 }
@@ -289,7 +289,7 @@ struct Body *crypt_pgp_sign_message(struct Body *a)
 struct Body *crypt_pgp_encrypt_message(struct Body *a, char *keylist, bool sign)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_encrypt_message))
-    return (CRYPT_MOD_CALL(PGP, pgp_encrypt_message))(a, keylist, sign);
+    return CRYPT_MOD_CALL(PGP, pgp_encrypt_message)(a, keylist, sign);
 
   return NULL;
 }
@@ -300,7 +300,7 @@ struct Body *crypt_pgp_encrypt_message(struct Body *a, char *keylist, bool sign)
 void crypt_pgp_invoke_import(const char *fname)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_invoke_import))
-    (CRYPT_MOD_CALL(PGP, pgp_invoke_import))(fname);
+    CRYPT_MOD_CALL(PGP, pgp_invoke_import)(fname);
 }
 
 /**
@@ -309,7 +309,7 @@ void crypt_pgp_invoke_import(const char *fname)
 int crypt_pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, verify_one))
-    return (CRYPT_MOD_CALL(PGP, verify_one))(sigbdy, s, tempf);
+    return CRYPT_MOD_CALL(PGP, verify_one)(sigbdy, s, tempf);
 
   return -1;
 }
@@ -320,7 +320,7 @@ int crypt_pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempf
 int crypt_pgp_send_menu(struct Header *msg)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, send_menu))
-    return (CRYPT_MOD_CALL(PGP, send_menu))(msg);
+    return CRYPT_MOD_CALL(PGP, send_menu)(msg);
 
   return 0;
 }
@@ -331,7 +331,7 @@ int crypt_pgp_send_menu(struct Header *msg)
 void crypt_pgp_extract_key_from_attachment(FILE *fp, struct Body *top)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, pgp_extract_key_from_attachment))
-    (CRYPT_MOD_CALL(PGP, pgp_extract_key_from_attachment))(fp, top);
+    CRYPT_MOD_CALL(PGP, pgp_extract_key_from_attachment)(fp, top);
 }
 
 /**
@@ -340,7 +340,7 @@ void crypt_pgp_extract_key_from_attachment(FILE *fp, struct Body *top)
 void crypt_pgp_set_sender(const char *sender)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, set_sender))
-    (CRYPT_MOD_CALL(PGP, set_sender))(sender);
+    CRYPT_MOD_CALL(PGP, set_sender)(sender);
 }
 
 /**
@@ -349,7 +349,7 @@ void crypt_pgp_set_sender(const char *sender)
 void crypt_smime_void_passphrase(void)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, void_passphrase))
-    (CRYPT_MOD_CALL(SMIME, void_passphrase))();
+    CRYPT_MOD_CALL(SMIME, void_passphrase)();
 }
 
 /**
@@ -358,7 +358,7 @@ void crypt_smime_void_passphrase(void)
 int crypt_smime_valid_passphrase(void)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, valid_passphrase))
-    return (CRYPT_MOD_CALL(SMIME, valid_passphrase))();
+    return CRYPT_MOD_CALL(SMIME, valid_passphrase)();
 
   return 0;
 }
@@ -369,7 +369,7 @@ int crypt_smime_valid_passphrase(void)
 int crypt_smime_decrypt_mime(FILE *a, FILE **b, struct Body *c, struct Body **d)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, decrypt_mime))
-    return (CRYPT_MOD_CALL(SMIME, decrypt_mime))(a, b, c, d);
+    return CRYPT_MOD_CALL(SMIME, decrypt_mime)(a, b, c, d);
 
   return -1;
 }
@@ -380,7 +380,7 @@ int crypt_smime_decrypt_mime(FILE *a, FILE **b, struct Body *c, struct Body **d)
 int crypt_smime_application_handler(struct Body *m, struct State *s)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, application_handler))
-    return (CRYPT_MOD_CALL(SMIME, application_handler))(m, s);
+    return CRYPT_MOD_CALL(SMIME, application_handler)(m, s);
 
   return -1;
 }
@@ -391,7 +391,7 @@ int crypt_smime_application_handler(struct Body *m, struct State *s)
 void crypt_smime_encrypted_handler(struct Body *a, struct State *s)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, encrypted_handler))
-    (CRYPT_MOD_CALL(SMIME, encrypted_handler))(a, s);
+    CRYPT_MOD_CALL(SMIME, encrypted_handler)(a, s);
 }
 
 /**
@@ -400,7 +400,7 @@ void crypt_smime_encrypted_handler(struct Body *a, struct State *s)
 void crypt_smime_getkeys(struct Envelope *env)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, smime_getkeys))
-    (CRYPT_MOD_CALL(SMIME, smime_getkeys))(env);
+    CRYPT_MOD_CALL(SMIME, smime_getkeys)(env);
 }
 
 /**
@@ -409,7 +409,7 @@ void crypt_smime_getkeys(struct Envelope *env)
 int crypt_smime_verify_sender(struct Header *h)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, smime_verify_sender))
-    return (CRYPT_MOD_CALL(SMIME, smime_verify_sender))(h);
+    return CRYPT_MOD_CALL(SMIME, smime_verify_sender)(h);
 
   return 1;
 }
@@ -420,7 +420,7 @@ int crypt_smime_verify_sender(struct Header *h)
 char *crypt_smime_find_keys(struct Address *addrlist, bool oppenc_mode)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, find_keys))
-    return (CRYPT_MOD_CALL(SMIME, find_keys))(addrlist, oppenc_mode);
+    return CRYPT_MOD_CALL(SMIME, find_keys)(addrlist, oppenc_mode);
 
   return NULL;
 }
@@ -431,7 +431,7 @@ char *crypt_smime_find_keys(struct Address *addrlist, bool oppenc_mode)
 struct Body *crypt_smime_sign_message(struct Body *a)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, sign_message))
-    return (CRYPT_MOD_CALL(SMIME, sign_message))(a);
+    return CRYPT_MOD_CALL(SMIME, sign_message)(a);
 
   return NULL;
 }
@@ -442,7 +442,7 @@ struct Body *crypt_smime_sign_message(struct Body *a)
 struct Body *crypt_smime_build_smime_entity(struct Body *a, char *certlist)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, smime_build_smime_entity))
-    return (CRYPT_MOD_CALL(SMIME, smime_build_smime_entity))(a, certlist);
+    return CRYPT_MOD_CALL(SMIME, smime_build_smime_entity)(a, certlist);
 
   return NULL;
 }
@@ -453,7 +453,7 @@ struct Body *crypt_smime_build_smime_entity(struct Body *a, char *certlist)
 void crypt_smime_invoke_import(char *infile, char *mailbox)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, smime_invoke_import))
-    (CRYPT_MOD_CALL(SMIME, smime_invoke_import))(infile, mailbox);
+    CRYPT_MOD_CALL(SMIME, smime_invoke_import)(infile, mailbox);
 }
 
 /**
@@ -462,7 +462,7 @@ void crypt_smime_invoke_import(char *infile, char *mailbox)
 int crypt_smime_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, verify_one))
-    return (CRYPT_MOD_CALL(SMIME, verify_one))(sigbdy, s, tempf);
+    return CRYPT_MOD_CALL(SMIME, verify_one)(sigbdy, s, tempf);
 
   return -1;
 }
@@ -473,7 +473,7 @@ int crypt_smime_verify_one(struct Body *sigbdy, struct State *s, const char *tem
 int crypt_smime_send_menu(struct Header *msg)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, send_menu))
-    return (CRYPT_MOD_CALL(SMIME, send_menu))(msg);
+    return CRYPT_MOD_CALL(SMIME, send_menu)(msg);
 
   return 0;
 }
@@ -484,5 +484,5 @@ int crypt_smime_send_menu(struct Header *msg)
 void crypt_smime_set_sender(const char *sender)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, set_sender))
-    (CRYPT_MOD_CALL(SMIME, set_sender))(sender);
+    CRYPT_MOD_CALL(SMIME, set_sender)(sender);
 }