replace 'ADDRESS' with 'struct Address'

diff --git a/addrbook.c b/addrbook.c
index dc4742efaaffec318557aaa350b44bf1cc097107..9c9d4bf0e40ea52826ec4f31c82850b0e7b1a65b 100644 (file)
--- a/addrbook.c
+++ b/addrbook.c
@@ -96,8 +96,8 @@ static int alias_sort_alias(const void *a, const void *b)
 
 static int alias_sort_address(const void *a, const void *b)
 {
-  ADDRESS *pa = (*(ALIAS **) a)->addr;
-  ADDRESS *pb = (*(ALIAS **) b)->addr;
+  struct Address *pa = (*(ALIAS **) a)->addr;
+  struct Address *pb = (*(ALIAS **) b)->addr;
   int r;
 
   if (pa == pb)

diff --git a/alias.c b/alias.c
index 0f2bffbff03b3a6321e1d573886e30b180c64b8c..6fae19d4e8c37c25d894688673090c86566b25f8 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -26,7 +26,7 @@
 
 int mutt_check_alias_name(const char *s, char *dest, size_t destlen);
 
-ADDRESS *mutt_lookup_alias(const char *s)
+struct Address *mutt_lookup_alias(const char *s)
 {
   ALIAS *t = Aliases;
 
@@ -36,9 +36,9 @@ ADDRESS *mutt_lookup_alias(const char *s)
   return NULL; /* no such alias */
 }
 
-static ADDRESS *expand_aliases_r(ADDRESS *a, LIST **expn)
+static struct Address *expand_aliases_r(struct Address *a, LIST **expn)
 {
-  ADDRESS *head = NULL, *last = NULL, *t = NULL, *w = NULL;
+  struct Address *head = NULL, *last = NULL, *t = NULL, *w = NULL;
   LIST *u = NULL;
   char i;
   const char *fqdn = NULL;
@@ -121,9 +121,9 @@ static ADDRESS *expand_aliases_r(ADDRESS *a, LIST **expn)
   return head;
 }
 
-ADDRESS *mutt_expand_aliases(ADDRESS *a)
+struct Address *mutt_expand_aliases(struct Address *a)
 {
-  ADDRESS *t = NULL;
+  struct Address *t = NULL;
   LIST *expn = NULL; /* previously expanded aliases to avoid loops */
 
   t = expand_aliases_r(a, &expn);
@@ -173,9 +173,9 @@ static void write_safe_address(FILE *fp, char *s)
   }
 }
 
-ADDRESS *mutt_get_address(ENVELOPE *env, char **pfxp)
+struct Address *mutt_get_address(ENVELOPE *env, char **pfxp)
 {
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
   char *pfx = NULL;
 
   if (mutt_addr_is_user(env->from))
@@ -222,14 +222,14 @@ static void recode_buf(char *buf, size_t buflen)
   FREE(&s);
 }
 
-void mutt_create_alias(ENVELOPE *cur, ADDRESS *iadr)
+void mutt_create_alias(ENVELOPE *cur, struct Address *iadr)
 {
   ALIAS *new = NULL, *t = NULL;
   char buf[LONG_STRING], tmp[LONG_STRING], prompt[SHORT_STRING], *pc = NULL;
   char *err = NULL;
   char fixed[LONG_STRING];
   FILE *rc = NULL;
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
 
   if (cur)
   {
@@ -439,7 +439,7 @@ int mutt_check_alias_name(const char *s, char *dest, size_t destlen)
  * This routine looks to see if the user has an alias defined for the given
  * address.
  */
-ADDRESS *alias_reverse_lookup(ADDRESS *a)
+struct Address *alias_reverse_lookup(struct Address *a)
 {
   if (!a || !a->mailbox)
     return NULL;
@@ -449,7 +449,7 @@ ADDRESS *alias_reverse_lookup(ADDRESS *a)
 
 void mutt_alias_add_reverse(ALIAS *t)
 {
-  ADDRESS *ap = NULL;
+  struct Address *ap = NULL;
   if (!t)
     return;
 
@@ -467,7 +467,7 @@ void mutt_alias_add_reverse(ALIAS *t)
 
 void mutt_alias_delete_reverse(ALIAS *t)
 {
-  ADDRESS *ap = NULL;
+  struct Address *ap = NULL;
   if (!t)
     return;
 
@@ -604,7 +604,7 @@ static bool string_is_address(const char *str, const char *u, const char *d)
 }
 
 /* returns true if the given address belongs to the user. */
-bool mutt_addr_is_user(ADDRESS *addr)
+bool mutt_addr_is_user(struct Address *addr)
 {
   const char *fqdn = NULL;
 

diff --git a/commands.c b/commands.c
index 209cf4ede4e8dcd0e762da1809da006cee1eb000..f9a0f4ccd6addd09c5ac8e328c6b36c52b00fa13 100644 (file)
--- a/commands.c
+++ b/commands.c
@@ -243,7 +243,7 @@ void ci_bounce_message(HEADER *h)
   char prompt[SHORT_STRING];
   char scratch[SHORT_STRING];
   char buf[HUGE_STRING] = { 0 };
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
   char *err = NULL;
   int rc;
 
@@ -631,7 +631,7 @@ void mutt_display_address(ENVELOPE *env)
 {
   char *pfx = NULL;
   char buf[SHORT_STRING];
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
 
   adr = mutt_get_address(env, &pfx);
 

diff --git a/compose.c b/compose.c
index b83c30dd465362296f6b370b84c6c82cb0529f83..dfa56c568ef376c16c617719ee83c87831f479f0 100644 (file)
--- a/compose.c
+++ b/compose.c
@@ -282,7 +282,7 @@ static int check_attachments(ATTACHPTR **idx, short idxlen)
   return 0;
 }
 
-static void draw_envelope_addr(int line, ADDRESS *addr)
+static void draw_envelope_addr(int line, struct Address *addr)
 {
   char buf[LONG_STRING];
 
@@ -349,7 +349,7 @@ static void draw_envelope(HEADER *msg, char *fcc)
   NORMAL_COLOR;
 }
 
-static void edit_address_list(int line, ADDRESS **addr)
+static void edit_address_list(int line, struct Address **addr)
 {
   char buf[HUGE_STRING] = ""; /* needs to be large for alias expansion */
   char *err = NULL;

diff --git a/copy.c b/copy.c
index af01f81317cbf311eb4622b5210f75611f9873e7..2a65f8f8ebfaf13a2c93a9a50c7dfc3439c24b64 100644 (file)
--- a/copy.c
+++ b/copy.c
@@ -842,7 +842,7 @@ static int copy_delete_attach(BODY *b, FILE *fpin, FILE *fpout, char *date)
  *
  * XXX - fix that.
  */
-static void format_address_header(char **h, ADDRESS *a)
+static void format_address_header(char **h, struct Address *a)
 {
   char buf[HUGE_STRING];
   char cbuf[STRING];
@@ -857,7 +857,7 @@ static void format_address_header(char **h, ADDRESS *a)
   safe_realloc(h, buflen);
   for (count = 0; a; a = a->next, count++)
   {
-    ADDRESS *tmp = a->next;
+    struct Address *tmp = a->next;
     a->next = NULL;
     *buf = *cbuf = *c2buf = '\0';
     l = rfc822_write_address(buf, sizeof(buf), a, 0);
@@ -906,8 +906,8 @@ static int address_header_decode(char **h)
   char *s = *h;
   int l, rp = 0;
 
-  ADDRESS *a = NULL;
-  ADDRESS *cur = NULL;
+  struct Address *a = NULL;
+  struct Address *cur = NULL;
 
   switch (tolower((unsigned char) *s))
   {

diff --git a/crypt.c b/crypt.c
index b4af13ed3a6ac350b8aa94ccde6a0a29b30a6b55..bddd05a56acaf393ec1d3248c87ac43cb74909a4 100644 (file)
--- a/crypt.c
+++ b/crypt.c
@@ -664,7 +664,7 @@ void crypt_extract_keys_from_messages(HEADER *h)
 {
   int i;
   char tempfname[_POSIX_PATH_MAX], *mbox = NULL;
-  ADDRESS *tmp = NULL;
+  struct Address *tmp = NULL;
   FILE *fpout = NULL;
 
   if (!WithCrypto)
@@ -783,7 +783,7 @@ void crypt_extract_keys_from_messages(HEADER *h)
 
 int crypt_get_keys(HEADER *msg, char **keylist, int oppenc_mode)
 {
-  ADDRESS *adrlist = NULL, *last = NULL;
+  struct Address *adrlist = NULL, *last = NULL;
   const char *fqdn = mutt_fqdn(1);
 
   /* Do a quick check to make sure that we can find all of the encryption

diff --git a/crypt_gpgme.c b/crypt_gpgme.c
index 70d702cfb473a5f2d0c0758a14d2f3be5c8c59f7..290c24080fdbd1bb7f19564b97e8111ab2a052ef 100644 (file)
--- a/crypt_gpgme.c
+++ b/crypt_gpgme.c
@@ -337,7 +337,7 @@ static int crypt_id_is_valid(crypt_key_t *key)
 
 /* Return a bit vector describing how well the addresses ADDR and
    U_ADDR match and whether KEY is valid. */
-static int crypt_id_matches_addr(ADDRESS *addr, ADDRESS *u_addr, crypt_key_t *key)
+static int crypt_id_matches_addr(struct Address *addr, struct Address *u_addr, crypt_key_t *key)
 {
   int rv = 0;
 
@@ -3837,7 +3837,7 @@ static LIST *crypt_add_string_to_hints(LIST *hints, const char *str)
 /* Display a menu to select a key from the array KEYS. FORCED_VALID
    will be set to true on return if the user did override the
    key's validity. */
-static crypt_key_t *crypt_select_key(crypt_key_t *keys, ADDRESS *p, const char *s,
+static crypt_key_t *crypt_select_key(crypt_key_t *keys, struct Address *p, const char *s,
                                      unsigned int app, int *forced_valid)
 {
   int keymax;
@@ -4031,10 +4031,10 @@ static crypt_key_t *crypt_select_key(crypt_key_t *keys, ADDRESS *p, const char *
   return k;
 }
 
-static crypt_key_t *crypt_getkeybyaddr(ADDRESS *a, short abilities, unsigned int app,
+static crypt_key_t *crypt_getkeybyaddr(struct Address *a, short abilities, unsigned int app,
                                        int *forced_valid, int oppenc_mode)
 {
-  ADDRESS *r = NULL, *p = NULL;
+  struct Address *r = NULL, *p = NULL;
   LIST *hints = NULL;
 
   int weak = 0;
@@ -4308,7 +4308,7 @@ static crypt_key_t *crypt_ask_for_key(char *tag, char *whatfor, short abilities,
    message.  It returns NULL if any of the keys can not be found.
    If oppenc_mode is true, only keys that can be determined without
    prompting will be used.  */
-static char *find_keys(ADDRESS *adrlist, unsigned int app, int oppenc_mode)
+static char *find_keys(struct Address *adrlist, unsigned int app, int oppenc_mode)
 {
   LIST *crypt_hook_list = NULL, *crypt_hook = NULL;
   char *crypt_hook_val = NULL;
@@ -4316,8 +4316,8 @@ static char *find_keys(ADDRESS *adrlist, unsigned int app, int oppenc_mode)
   char *keylist = NULL, *t = NULL;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
-  ADDRESS *addr = NULL;
-  ADDRESS *p = NULL, *q = NULL;
+  struct Address *addr = NULL;
+  struct Address *p = NULL, *q = NULL;
   crypt_key_t *k_info = NULL;
   const char *fqdn = mutt_fqdn(1);
   char buf[LONG_STRING];
@@ -4430,12 +4430,12 @@ static char *find_keys(ADDRESS *adrlist, unsigned int app, int oppenc_mode)
   return keylist;
 }
 
-char *pgp_gpgme_findkeys(ADDRESS *adrlist, int oppenc_mode)
+char *pgp_gpgme_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return find_keys(adrlist, APPLICATION_PGP, oppenc_mode);
 }
 
-char *smime_gpgme_findkeys(ADDRESS *adrlist, int oppenc_mode)
+char *smime_gpgme_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return find_keys(adrlist, APPLICATION_SMIME, oppenc_mode);
 }
@@ -4734,7 +4734,7 @@ int smime_gpgme_send_menu(HEADER *msg)
 
 static int verify_sender(HEADER *h, gpgme_protocol_t protocol)
 {
-  ADDRESS *sender = NULL;
+  struct Address *sender = NULL;
   unsigned int ret = 1;
 
   if (h->env->from)

diff --git a/crypt_gpgme.h b/crypt_gpgme.h
index f72fe6bc661613f3efe5c75fd27d0db034ccff22..e173f0edc165d6e34da634188b9020c90a497bb9 100644 (file)
--- a/crypt_gpgme.h
+++ b/crypt_gpgme.h
@@ -23,8 +23,8 @@
 void pgp_gpgme_init(void);
 void smime_gpgme_init(void);
 
-char *pgp_gpgme_findkeys(ADDRESS *adrlist, int oppenc_mode);
-char *smime_gpgme_findkeys(ADDRESS *adrlist, int oppenc_mode);
+char *pgp_gpgme_findkeys(struct Address *adrlist, int oppenc_mode);
+char *smime_gpgme_findkeys(struct Address *adrlist, int oppenc_mode);
 
 BODY *pgp_gpgme_encrypt_message(BODY *a, char *keylist, int sign);
 BODY *smime_gpgme_build_smime_entity(BODY *a, char *keylist);

diff --git a/crypt_mod.h b/crypt_mod.h
index 62e393317c85ea1a5517c324154261bfd874d82a..8f8f3ce5433a87b458895257eb019b55bcc896c0 100644 (file)
--- a/crypt_mod.h
+++ b/crypt_mod.h
@@ -35,11 +35,11 @@ typedef int (*crypt_func_decrypt_mime_t)(FILE *a, FILE **b, BODY *c, BODY **d);
 typedef int (*crypt_func_application_handler_t)(BODY *m, STATE *s);
 typedef int (*crypt_func_encrypted_handler_t)(BODY *m, STATE *s);
 
-typedef void (*crypt_func_pgp_invoke_getkeys_t)(ADDRESS *addr);
+typedef void (*crypt_func_pgp_invoke_getkeys_t)(struct Address *addr);
 typedef int (*crypt_func_pgp_check_traditional_t)(FILE *fp, BODY *b, int tagged_only);
 typedef BODY *(*crypt_func_pgp_traditional_encryptsign_t)(BODY *a, int flags, char *keylist);
 typedef BODY *(*crypt_func_pgp_make_key_attachment_t)(char *tempf);
-typedef char *(*crypt_func_findkeys_t)(ADDRESS *adrlist, int oppenc_mode);
+typedef char *(*crypt_func_findkeys_t)(struct Address *adrlist, int oppenc_mode);
 typedef BODY *(*crypt_func_sign_message_t)(BODY *a);
 typedef BODY *(*crypt_func_pgp_encrypt_message_t)(BODY *a, char *keylist, int sign);
 typedef void (*crypt_func_pgp_invoke_import_t)(const char *fname);

diff --git a/crypt_mod_pgp_classic.c b/crypt_mod_pgp_classic.c
index 91ea968b6618fc9bc06c21eb53adbfc2b931f90a..abefdb2ad2275bc7192912a399778d564eda41fc 100644 (file)
--- a/crypt_mod_pgp_classic.c
+++ b/crypt_mod_pgp_classic.c
@@ -42,7 +42,7 @@ static int crypt_mod_pgp_application_handler(BODY *m, STATE *s)
   return pgp_application_pgp_handler(m, s);
 }
 
-static char *crypt_mod_pgp_findkeys(ADDRESS *adrlist, int oppenc_mode)
+static char *crypt_mod_pgp_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return pgp_find_keys(adrlist, oppenc_mode);
 }
@@ -87,7 +87,7 @@ static int crypt_mod_pgp_encrypted_handler(BODY *m, STATE *s)
   return pgp_encrypted_handler(m, s);
 }
 
-static void crypt_mod_pgp_invoke_getkeys(ADDRESS *addr)
+static void crypt_mod_pgp_invoke_getkeys(struct Address *addr)
 {
   pgp_invoke_getkeys(addr);
 }

diff --git a/crypt_mod_pgp_gpgme.c b/crypt_mod_pgp_gpgme.c
index 732349c76943629ec4b26be66eed334469b49559..84a2dab81eee587c87741123ffcd0d08289d4972 100644 (file)
--- a/crypt_mod_pgp_gpgme.c
+++ b/crypt_mod_pgp_gpgme.c
@@ -64,7 +64,7 @@ static void crypt_mod_pgp_invoke_import(const char *fname)
   pgp_gpgme_invoke_import(fname);
 }
 
-static char *crypt_mod_pgp_findkeys(ADDRESS *adrlist, int oppenc_mode)
+static char *crypt_mod_pgp_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return pgp_gpgme_findkeys(adrlist, oppenc_mode);
 }

diff --git a/crypt_mod_smime_classic.c b/crypt_mod_smime_classic.c
index 9a22f3bba726dc42fab309c4389549aaee1af0aa..627aae9fa43cf5992f0f438bd312368eb35047dc 100644 (file)
--- a/crypt_mod_smime_classic.c
+++ b/crypt_mod_smime_classic.c
@@ -42,7 +42,7 @@ static int crypt_mod_smime_application_handler(BODY *m, STATE *s)
   return smime_application_smime_handler(m, s);
 }
 
-static char *crypt_mod_smime_findkeys(ADDRESS *adrlist, int oppenc_mode)
+static char *crypt_mod_smime_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return smime_find_keys(adrlist, oppenc_mode);
 }

diff --git a/crypt_mod_smime_gpgme.c b/crypt_mod_smime_gpgme.c
index ba2f9acf31e8faa3bdd9fb6468088bb9c439341e..77508a1e01cbde54e01548478da742590bead4e0 100644 (file)
--- a/crypt_mod_smime_gpgme.c
+++ b/crypt_mod_smime_gpgme.c
@@ -49,7 +49,7 @@ static int crypt_mod_smime_application_handler(BODY *m, STATE *s)
   return smime_gpgme_application_handler(m, s);
 }
 
-static char *crypt_mod_smime_findkeys(ADDRESS *adrlist, int oppenc_mode)
+static char *crypt_mod_smime_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   return smime_gpgme_findkeys(adrlist, oppenc_mode);
 }

diff --git a/cryptglue.c b/cryptglue.c
index d19c4cc31378d85295f9de65f2dedf110a3ab2d1..78d347db932426ca9cf868c3df49702c7cd52ba9 100644 (file)
--- a/cryptglue.c
+++ b/cryptglue.c
@@ -160,7 +160,7 @@ int crypt_pgp_encrypted_handler(BODY *a, STATE *s)
 }
 
 /* fixme: needs documentation. */
-void crypt_pgp_invoke_getkeys(ADDRESS *addr)
+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);
@@ -197,7 +197,7 @@ BODY *crypt_pgp_make_key_attachment(char *tempf)
    message.  It returns NULL if any of the keys can not be found.
    If oppenc_mode is true, only keys that can be determined without
    prompting will be used.  */
-char *crypt_pgp_findkeys(ADDRESS *adrlist, int oppenc_mode)
+char *crypt_pgp_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   if (CRYPT_MOD_CALL_CHECK(PGP, findkeys))
     return (CRYPT_MOD_CALL(PGP, findkeys))(adrlist, oppenc_mode);
@@ -331,7 +331,7 @@ int crypt_smime_verify_sender(HEADER *h)
    message.  It returns NULL if any of the keys can not be found.
    If oppenc_mode is true, only keys that can be determined without
    prompting will be used.  */
-char *crypt_smime_findkeys(ADDRESS *adrlist, int oppenc_mode)
+char *crypt_smime_findkeys(struct Address *adrlist, int oppenc_mode)
 {
   if (CRYPT_MOD_CALL_CHECK(SMIME, findkeys))
     return (CRYPT_MOD_CALL(SMIME, findkeys))(adrlist, oppenc_mode);

diff --git a/globals.h b/globals.h
index 1b6014c145e71c8671c67cf2c36f15a4358daecf..f8efd1b3d1d48cf6aaec6f69b9230b840fc8e368 100644 (file)
--- a/globals.h
+++ b/globals.h
@@ -30,8 +30,8 @@ WHERE char AttachmentMarker[STRING];
 WHERE char *MuttDotlock;
 #endif
 
-WHERE ADDRESS *EnvFrom;
-WHERE ADDRESS *From;
+WHERE struct Address *EnvFrom;
+WHERE struct Address *From;
 
 WHERE char *AliasFile;
 WHERE char *AliasFmt;

diff --git a/group.c b/group.c
index 7d4ef98d8f5eddf9293cff6e73f0b01ccc44176b..101277cfa62df7623b2af54d52454a06f80a6f7a 100644 (file)
--- a/group.c
+++ b/group.c
@@ -100,9 +100,9 @@ void mutt_group_context_destroy(group_context_t **ctx)
   }
 }
 
-static void group_add_adrlist(group_t *g, ADDRESS *a)
+static void group_add_adrlist(group_t *g, struct Address *a)
 {
-  ADDRESS **p = NULL, *q = NULL;
+  struct Address **p = NULL, *q = NULL;
 
   if (!g)
     return;
@@ -117,9 +117,9 @@ static void group_add_adrlist(group_t *g, ADDRESS *a)
   *p = q;
 }
 
-static int group_remove_adrlist(group_t *g, ADDRESS *a)
+static int group_remove_adrlist(group_t *g, struct Address *a)
 {
-  ADDRESS *p = NULL;
+  struct Address *p = NULL;
 
   if (!g)
     return -1;
@@ -142,13 +142,13 @@ static int group_remove_rx(group_t *g, const char *s)
   return mutt_remove_from_rx_list(&g->rs, s);
 }
 
-void mutt_group_context_add_adrlist(group_context_t *ctx, ADDRESS *a)
+void mutt_group_context_add_adrlist(group_context_t *ctx, struct Address *a)
 {
   for (; ctx; ctx = ctx->next)
     group_add_adrlist(ctx->g, a);
 }
 
-int mutt_group_context_remove_adrlist(group_context_t *ctx, ADDRESS *a)
+int mutt_group_context_remove_adrlist(group_context_t *ctx, struct Address *a)
 {
   int rv = 0;
 
@@ -188,7 +188,7 @@ int mutt_group_context_remove_rx(group_context_t *ctx, const char *s)
 
 bool mutt_group_match(group_t *g, const char *s)
 {
-  ADDRESS *ap = NULL;
+  struct Address *ap = NULL;
 
   if (s && g)
   {

diff --git a/group.h b/group.h
index 1a145990913f40e0df51022576779e44f8bff31d..8fe3df0bece25c6760bd3f6e341aedf44981db75 100644 (file)
--- a/group.h
+++ b/group.h
@@ -24,13 +24,13 @@
 
 void mutt_group_context_add(group_context_t **ctx, group_t *group);
 void mutt_group_context_destroy(group_context_t **ctx);
-void mutt_group_context_add_adrlist(group_context_t *ctx, ADDRESS *a);
+void mutt_group_context_add_adrlist(group_context_t *ctx, struct Address *a);
 int mutt_group_context_add_rx(group_context_t *ctx, const char *s, int flags, BUFFER *err);
 
 bool mutt_group_match(group_t *g, const char *s);
 
 int mutt_group_context_clear(group_context_t **ctx);
 int mutt_group_context_remove_rx(group_context_t *ctx, const char *s);
-int mutt_group_context_remove_adrlist(group_context_t *ctx, ADDRESS *a);
+int mutt_group_context_remove_adrlist(group_context_t *ctx, struct Address *a);
 
 #endif /* _MUTT_GROUP_H */

diff --git a/hcache/hcache.c b/hcache/hcache.c
index 3936a9ef31482597eb735915272637fcb9fedeca..bae5a170d924eb6f1af328ea60ecf289da293bfe 100644 (file)
--- a/hcache/hcache.c
+++ b/hcache/hcache.c
@@ -211,7 +211,7 @@ static void restore_char(char **c, const unsigned char *d, int *off, int convert
   *off += size;
 }
 
-static unsigned char *dump_address(ADDRESS *a, unsigned char *d, int *off, int convert)
+static unsigned char *dump_address(struct Address *a, unsigned char *d, int *off, int convert)
 {
   unsigned int counter = 0;
   unsigned int start_off = *off;
@@ -235,7 +235,7 @@ static unsigned char *dump_address(ADDRESS *a, unsigned char *d, int *off, int c
   return d;
 }
 
-static void restore_address(ADDRESS **a, const unsigned char *d, int *off, int convert)
+static void restore_address(struct Address **a, const unsigned char *d, int *off, int convert)
 {
   unsigned int counter;
 

diff --git a/hdrline.c b/hdrline.c
index dd8c94d8ed3ecbb40b1f80028e689f9c2c54276d..7f1de2dd214ceb2c9b73bd372f3e31d1c353f3d1 100644 (file)
--- a/hdrline.c
+++ b/hdrline.c
@@ -48,14 +48,14 @@ enum
   FlagCharZEmpty
 };
 
-bool mutt_is_mail_list(ADDRESS *addr)
+bool mutt_is_mail_list(struct Address *addr)
 {
   if (!mutt_match_rx_list(addr->mailbox, UnMailLists))
     return mutt_match_rx_list(addr->mailbox, MailLists);
   return false;
 }
 
-bool mutt_is_subscribed_list(ADDRESS *addr)
+bool mutt_is_subscribed_list(struct Address *addr)
 {
   if (!mutt_match_rx_list(addr->mailbox, UnMailLists) &&
       !mutt_match_rx_list(addr->mailbox, UnSubscribedLists))
@@ -67,7 +67,7 @@ bool mutt_is_subscribed_list(ADDRESS *addr)
  * If one is found, print pfx and the name of the list into buf, then
  * return 1.  Otherwise, simply return 0.
  */
-static bool check_for_mailing_list(ADDRESS *adr, const char *pfx, char *buf, int buflen)
+static bool check_for_mailing_list(struct Address *adr, const char *pfx, char *buf, int buflen)
 {
   for (; adr; adr = adr->next)
   {
@@ -85,7 +85,7 @@ static bool check_for_mailing_list(ADDRESS *adr, const char *pfx, char *buf, int
  * If one is found, print the address of the list into buf, then return 1.
  * Otherwise, simply return 0.
  */
-static bool check_for_mailing_list_addr(ADDRESS *adr, char *buf, int buflen)
+static bool check_for_mailing_list_addr(struct Address *adr, char *buf, int buflen)
 {
   for (; adr; adr = adr->next)
   {
@@ -100,7 +100,7 @@ static bool check_for_mailing_list_addr(ADDRESS *adr, char *buf, int buflen)
 }
 
 
-static bool first_mailing_list(char *buf, size_t buflen, ADDRESS *a)
+static bool first_mailing_list(char *buf, size_t buflen, struct Address *a)
 {
   for (; a; a = a->next)
   {
@@ -220,7 +220,7 @@ static void make_from(ENVELOPE *env, char *buf, size_t len, int do_lists)
 
   bool me;
   enum FieldType disp;
-  ADDRESS *name = NULL;
+  struct Address *name = NULL;
 
   me = mutt_addr_is_user(env->from);
 
@@ -286,7 +286,7 @@ static void make_from_addr(ENVELOPE *hdr, char *buf, size_t len, int do_lists)
     *buf = 0;
 }
 
-static bool user_in_addr(ADDRESS *a)
+static bool user_in_addr(struct Address *a)
 {
   for (; a; a = a->next)
     if (mutt_addr_is_user(a))

diff --git a/hook.c b/hook.c
index 4ed2715ddc7e5e26cb99eb0352347e554e26e83d..3d16c23112b4bcfa43f4ed6283c544a70064f68c 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -441,7 +441,7 @@ void mutt_default_save(char *path, size_t pathlen, HEADER *hdr)
   if (addr_hook(path, pathlen, MUTT_SAVEHOOK, Context, hdr) != 0)
   {
     char tmp[_POSIX_PATH_MAX];
-    ADDRESS *adr = NULL;
+    struct Address *adr = NULL;
     ENVELOPE *env = hdr->env;
     bool fromMe = mutt_addr_is_user(env->from);
 
@@ -465,7 +465,7 @@ void mutt_default_save(char *path, size_t pathlen, HEADER *hdr)
 
 void mutt_select_fcc(char *path, size_t pathlen, HEADER *hdr)
 {
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
   char buf[_POSIX_PATH_MAX];
   ENVELOPE *env = hdr->env;
 
@@ -522,7 +522,7 @@ char *mutt_iconv_hook(const char *chs)
   return _mutt_string_hook(chs, MUTT_ICONVHOOK);
 }
 
-LIST *mutt_crypt_hook(ADDRESS *adr)
+LIST *mutt_crypt_hook(struct Address *adr)
 {
   return _mutt_list_hook(adr->mailbox, MUTT_CRYPTHOOK);
 }

diff --git a/init.c b/init.c
index 33c5590da43e43cf121958b5d0fcd3b6a73b8794..cad169c9da4331857e23b899e9fdfeccfa06ab9f 100644 (file)
--- a/init.c
+++ b/init.c
@@ -429,8 +429,8 @@ int mutt_option_set(const struct option_t *val, BUFFER *err)
       }
       break;
       case DT_ADDR:
-        rfc822_free_address((ADDRESS **) MuttVars[idx].data);
-        *((ADDRESS **) MuttVars[idx].data) =
+        rfc822_free_address((struct Address **) MuttVars[idx].data);
+        *((struct Address **) MuttVars[idx].data) =
             rfc822_parse_adrlist(NULL, (const char *) val->data);
         break;
       case DT_PATH:
@@ -484,7 +484,7 @@ static void free_opt(struct option_t *p)
   switch (p->type & DT_MASK)
   {
     case DT_ADDR:
-      rfc822_free_address((ADDRESS **) p->data);
+      rfc822_free_address((struct Address **) p->data);
       break;
     case DT_RX:
       pp = (REGEXP *) p->data;
@@ -1236,7 +1236,7 @@ static int parse_group(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
 {
   group_context_t *gc = NULL;
   group_state_t state = NONE;
-  ADDRESS *addr = NULL;
+  struct Address *addr = NULL;
   char *estr = NULL;
 
   do
@@ -1758,7 +1758,7 @@ static int parse_alias(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
 #ifdef DEBUG
   if (debuglevel >= 2)
   {
-    ADDRESS *a = NULL;
+    struct Address *a = NULL;
     /* A group is terminated with an empty address, so check a->mailbox */
     for (a = tmp->addr; a && a->mailbox; a = a->next)
     {
@@ -1882,11 +1882,11 @@ static void set_default(struct option_t *p)
       }
       break;
     case DT_ADDR:
-      if (!p->init && *((ADDRESS **) p->data))
+      if (!p->init && *((struct Address **) p->data))
       {
         char tmp[HUGE_STRING];
         *tmp = '\0';
-        rfc822_write_address(tmp, sizeof(tmp), *((ADDRESS **) p->data), 0);
+        rfc822_write_address(tmp, sizeof(tmp), *((struct Address **) p->data), 0);
         p->init = (unsigned long) safe_strdup(tmp);
       }
       break;
@@ -1929,9 +1929,9 @@ static void restore_default(struct option_t *p)
       }
       break;
     case DT_ADDR:
-      rfc822_free_address((ADDRESS **) p->data);
+      rfc822_free_address((struct Address **) p->data);
       if (p->init)
-        *((ADDRESS **) p->data) = rfc822_parse_adrlist(NULL, (char *) p->init);
+        *((struct Address **) p->data) = rfc822_parse_adrlist(NULL, (char *) p->init);
       break;
     case DT_BOOL:
       if (p->init)
@@ -2463,7 +2463,7 @@ static int parse_set(BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err)
         if (myvar)
           myvar_del(myvar);
         else if (DTYPE(MuttVars[idx].type) == DT_ADDR)
-          rfc822_free_address((ADDRESS **) MuttVars[idx].data);
+          rfc822_free_address((struct Address **) MuttVars[idx].data);
         else if (DTYPE(MuttVars[idx].type) == DT_MBCHARTBL)
           free_mbchar_table((mbchar_table **) MuttVars[idx].data);
         else
@@ -2492,7 +2492,7 @@ static int parse_set(BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err)
         else if (DTYPE(MuttVars[idx].type) == DT_ADDR)
         {
           _tmp[0] = '\0';
-          rfc822_write_address(_tmp, sizeof(_tmp), *((ADDRESS **) MuttVars[idx].data), 0);
+          rfc822_write_address(_tmp, sizeof(_tmp), *((struct Address **) MuttVars[idx].data), 0);
           val = _tmp;
         }
         else if (DTYPE(MuttVars[idx].type) == DT_PATH)
@@ -2591,8 +2591,8 @@ static int parse_set(BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err)
         }
         else
         {
-          rfc822_free_address((ADDRESS **) MuttVars[idx].data);
-          *((ADDRESS **) MuttVars[idx].data) = rfc822_parse_adrlist(NULL, tmp->data);
+          rfc822_free_address((struct Address **) MuttVars[idx].data);
+          *((struct Address **) MuttVars[idx].data) = rfc822_parse_adrlist(NULL, tmp->data);
         }
       }
     }
@@ -3640,7 +3640,7 @@ int var_to_string(int idx, char *val, size_t len)
   }
   else if (DTYPE(MuttVars[idx].type) == DT_ADDR)
   {
-    rfc822_write_address(tmp, sizeof(tmp), *((ADDRESS **) MuttVars[idx].data), 0);
+    rfc822_write_address(tmp, sizeof(tmp), *((struct Address **) MuttVars[idx].data), 0);
   }
   else if (DTYPE(MuttVars[idx].type) == DT_QUAD)
     strfcpy(tmp, vals[quadoption(MuttVars[idx].data)], sizeof(tmp));

diff --git a/main.c b/main.c
index af59da4def8b85fecfd26a0357b57f9dd487589d..85cd6396b2abbabc5dd7ef8485df74d000c330a2 100644 (file)
--- a/main.c
+++ b/main.c
@@ -458,7 +458,7 @@ int main(int argc, char **argv, char **environ)
   if (alias_queries)
   {
     int rv = 0;
-    ADDRESS *a = NULL;
+    struct Address *a = NULL;
     for (; optind < argc; optind++)
       alias_queries = mutt_add_list(alias_queries, argv[optind]);
     for (; alias_queries; alias_queries = alias_queries->next)

diff --git a/mbox.c b/mbox.c
index 6a5b26f02c135a92589e645d421d0a39148b3ab1..b200d35cfa4d97bd451da9629b1ac6b061171d92 100644 (file)
--- a/mbox.c
+++ b/mbox.c
@@ -551,7 +551,7 @@ static int mbox_open_new_message(MESSAGE *msg, CONTEXT *dest, HEADER *hdr)
 }
 
 /* return 1 if address lists are strictly identical */
-static int strict_addrcmp(const ADDRESS *a, const ADDRESS *b)
+static int strict_addrcmp(const struct Address *a, const struct Address *b)
 {
   while (a && b)
   {

diff --git a/mutt.h b/mutt.h
index 6a59d50da8e8ab17fa7f1f9f470848201f9dcc80..f97b4178a91d91591701bf4e38dc66b1f01dd887 100644 (file)
--- a/mutt.h
+++ b/mutt.h
@@ -644,7 +644,7 @@ typedef struct alias
 {
   struct alias *self; /* XXX - ugly hack */
   char *name;
-  ADDRESS *addr;
+  struct Address *addr;
   struct alias *next;
   bool tagged;
   bool del;
@@ -653,15 +653,15 @@ typedef struct alias
 
 typedef struct envelope
 {
-  ADDRESS *return_path;
-  ADDRESS *from;
-  ADDRESS *to;
-  ADDRESS *cc;
-  ADDRESS *bcc;
-  ADDRESS *sender;
-  ADDRESS *reply_to;
-  ADDRESS *mail_followup_to;
-  ADDRESS *x_original_to;
+  struct Address *return_path;
+  struct Address *from;
+  struct Address *to;
+  struct Address *cc;
+  struct Address *bcc;
+  struct Address *sender;
+  struct Address *reply_to;
+  struct Address *mail_followup_to;
+  struct Address *x_original_to;
   char *list_post; /* this stores a mailto URL, or nothing */
   char *subject;
   char *real_subj; /* offset of the real subject */
@@ -916,7 +916,7 @@ typedef enum {
 
 typedef struct group_t
 {
-  ADDRESS *as;
+  struct Address *as;
   RX_LIST *rs;
   char *name;
 } group_t;

diff --git a/mutt_crypt.h b/mutt_crypt.h
index 41437a07447af2fadafe9a1a41f31cd2dd337dfb..b4912b2906474174804aa3151ba6f36f38bd9a5e 100644 (file)
--- a/mutt_crypt.h
+++ b/mutt_crypt.h
@@ -196,7 +196,7 @@ int crypt_pgp_application_pgp_handler(BODY *m, STATE *s);
 int crypt_pgp_encrypted_handler(BODY *a, STATE *s);
 
 /* fixme: needs documentation. */
-void crypt_pgp_invoke_getkeys(ADDRESS *addr);
+void crypt_pgp_invoke_getkeys(struct Address *addr);
 
 /* Check for a traditional PGP message in body B. */
 int crypt_pgp_check_traditional(FILE *fp, BODY *b, int tagged_only);
@@ -211,7 +211,7 @@ BODY *crypt_pgp_make_key_attachment(char *tempf);
    message.  It returns NULL if any of the keys can not be found.
    If oppenc_mode is true, only keys that can be determined without
    prompting will be used.  */
-char *crypt_pgp_findkeys(ADDRESS *adrlist, int oppenc_mode);
+char *crypt_pgp_findkeys(struct Address *adrlist, int oppenc_mode);
 
 /* Create a new body with a PGP signed message from A. */
 BODY *crypt_pgp_sign_message(BODY *a);
@@ -256,7 +256,7 @@ int crypt_smime_verify_sender(HEADER *h);
    message.  It returns NULL if any of the keys can not be found.
    If oppenc_mode is true, only keys that can be determined without
    prompting will be used.  */
-char *crypt_smime_findkeys(ADDRESS *adrlist, int oppenc_mode);
+char *crypt_smime_findkeys(struct Address *adrlist, int oppenc_mode);
 
 /* fixme: Needs documentation. */
 BODY *crypt_smime_sign_message(BODY *a);

diff --git a/mutt_idna.c b/mutt_idna.c
index 0e726441870018ebcdf8edce9ad2911c7d8536a5..8e29a6c18c2d2e8be7115e83fde9579cafb9e968 100644 (file)
--- a/mutt_idna.c
+++ b/mutt_idna.c
@@ -55,17 +55,17 @@ static int mbox_to_udomain(const char *mbx, char **user, char **domain)
   return 0;
 }
 
-static int addr_is_local(ADDRESS *a)
+static int addr_is_local(struct Address *a)
 {
   return (a->intl_checked && !a->is_intl);
 }
 
-static int addr_is_intl(ADDRESS *a)
+static int addr_is_intl(struct Address *a)
 {
   return (a->intl_checked && a->is_intl);
 }
 
-static void set_local_mailbox(ADDRESS *a, char *local_mailbox)
+static void set_local_mailbox(struct Address *a, char *local_mailbox)
 {
   FREE(&a->mailbox);
   a->mailbox = local_mailbox;
@@ -73,7 +73,7 @@ static void set_local_mailbox(ADDRESS *a, char *local_mailbox)
   a->is_intl = false;
 }
 
-static void set_intl_mailbox(ADDRESS *a, char *intl_mailbox)
+static void set_intl_mailbox(struct Address *a, char *intl_mailbox)
 {
   FREE(&a->mailbox);
   a->mailbox = intl_mailbox;
@@ -223,7 +223,7 @@ cleanup:
 
 /* higher level functions */
 
-int mutt_addrlist_to_intl(ADDRESS *a, char **err)
+int mutt_addrlist_to_intl(struct Address *a, char **err)
 {
   char *user = NULL, *domain = NULL;
   char *intl_mailbox = NULL;
@@ -255,7 +255,7 @@ int mutt_addrlist_to_intl(ADDRESS *a, char **err)
   return rv;
 }
 
-int mutt_addrlist_to_local(ADDRESS *a)
+int mutt_addrlist_to_local(struct Address *a)
 {
   char *user = NULL, *domain = NULL;
   char *local_mailbox = NULL;
@@ -277,7 +277,7 @@ int mutt_addrlist_to_local(ADDRESS *a)
 }
 
 /* convert just for displaying purposes */
-const char *mutt_addr_for_display(ADDRESS *a)
+const char *mutt_addr_for_display(struct Address *a)
 {
   char *user = NULL, *domain = NULL;
   static char *buff = NULL;

diff --git a/mutt_idna.h b/mutt_idna.h
index 4ae1fdb70cf0ef5cef5b87efd29bd0dda28fa7fb..ca22179ba557b1e7f9f464db2e43aa864d5a3bd3 100644 (file)
--- a/mutt_idna.h
+++ b/mutt_idna.h
@@ -47,12 +47,12 @@
 #endif /* HAVE_LIBIDN */
 
 
-int mutt_addrlist_to_intl(ADDRESS *a, char **err);
-int mutt_addrlist_to_local(ADDRESS *a);
+int mutt_addrlist_to_intl(struct Address *a, char **err);
+int mutt_addrlist_to_local(struct Address *a);
 
 void mutt_env_to_local(ENVELOPE *e);
 int mutt_env_to_intl(ENVELOPE *env, char **tag, char **err);
 
-const char *mutt_addr_for_display(ADDRESS *a);
+const char *mutt_addr_for_display(struct Address *a);
 
 #endif /* _MUTT_IDNA_H */

diff --git a/mutt_lua.c b/mutt_lua.c
index c3cff98ed3a3f142ebd003da459f6418d0f5a632..7e4c65fbaa0d1e0c91d4368b21605eab2a280e36 100644 (file)
--- a/mutt_lua.c
+++ b/mutt_lua.c
@@ -198,7 +198,7 @@ static int _lua_mutt_get(lua_State *l)
       case DT_ADDR:
       {
         char value[LONG_STRING] = "";
-        rfc822_write_address(value, LONG_STRING, *((ADDRESS **) opt->data), 0);
+        rfc822_write_address(value, LONG_STRING, *((struct Address **) opt->data), 0);
         lua_pushstring(l, value);
         return 1;
       }

diff --git a/muttlib.c b/muttlib.c
index 8d29ed2544d5c6775376c0e31fb278ec78d2abf7..5c158a6509a357b2ef592dc4987e46a54bf908ba 100644 (file)
--- a/muttlib.c
+++ b/muttlib.c
@@ -498,7 +498,7 @@ char *_mutt_expand_path(char *s, size_t slen, int rx)
       case '@':
       {
         HEADER *h = NULL;
-        ADDRESS *alias = NULL;
+        struct Address *alias = NULL;
 
         if ((alias = mutt_lookup_alias(s + 1)))
         {
@@ -1148,7 +1148,7 @@ int mutt_check_overwrite(const char *attname, const char *path, char *fname,
   return 0;
 }
 
-void mutt_save_path(char *d, size_t dsize, ADDRESS *a)
+void mutt_save_path(char *d, size_t dsize, struct Address *a)
 {
   if (a && a->mailbox)
   {
@@ -1166,7 +1166,7 @@ void mutt_save_path(char *d, size_t dsize, ADDRESS *a)
     *d = 0;
 }
 
-void mutt_safe_path(char *s, size_t l, ADDRESS *a)
+void mutt_safe_path(char *s, size_t l, struct Address *a)
 {
   char *p = NULL;
 

diff --git a/mx.c b/mx.c
index b5716339fc072e715287b4374e9b7febd89f7296..41ccd490d2fa4a35a737f8d4a37c0ff19052c87a 100644 (file)
--- a/mx.c
+++ b/mx.c
@@ -1275,7 +1275,7 @@ int mx_sync_mailbox(CONTEXT *ctx, int *index_hint)
  */
 MESSAGE *mx_open_new_message(CONTEXT *dest, HEADER *hdr, int flags)
 {
-  ADDRESS *p = NULL;
+  struct Address *p = NULL;
   MESSAGE *msg = NULL;
 
   if (!dest->mx_ops || !dest->mx_ops->open_new_msg)

diff --git a/parse.c b/parse.c
index 1534ef105e07c1372bc458c0ebc2d42c72c37216..9abfa47b3e8f3563acadfca4d0042a1bf8e668d1 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -1513,7 +1513,7 @@ ENVELOPE *mutt_read_rfc822_header(FILE *f, HEADER *hdr, short user_hdrs, short w
   return e;
 }
 
-ADDRESS *mutt_parse_adrlist(ADDRESS *p, const char *s)
+struct Address *mutt_parse_adrlist(struct Address *p, const char *s)
 {
   const char *q = NULL;
 

diff --git a/pattern.c b/pattern.c
index 3a25c19b2294a5a8cc0ca6123cc4ed6a0e48fdbb..51a2a62a29e8dfeb81c6215190946af22b2871a3 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -1319,12 +1319,12 @@ static int perform_or(struct pattern_t *pat, pattern_exec_flag flags,
 static int match_adrlist(pattern_t *pat, int match_personal, int n, ...)
 {
   va_list ap;
-  ADDRESS *a = NULL;
+  struct Address *a = NULL;
 
   va_start(ap, n);
   for (; n; n--)
   {
-    for (a = va_arg(ap, ADDRESS *); a; a = a->next)
+    for (a = va_arg(ap, struct Address *); a; a = a->next)
     {
       if (pat->alladdr ^ ((!pat->isalias || alias_reverse_lookup(a)) &&
                           ((a->mailbox && !patmatch(pat, a->mailbox)) ||
@@ -1350,7 +1350,7 @@ static bool match_reference(pattern_t *pat, LIST *refs)
 /*
  * Matches subscribed mailing lists
  */
-int mutt_is_list_recipient(int alladdr, ADDRESS *a1, ADDRESS *a2)
+int mutt_is_list_recipient(int alladdr, struct Address *a1, struct Address *a2)
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_subscribed_list(a1))
@@ -1366,7 +1366,7 @@ int mutt_is_list_recipient(int alladdr, ADDRESS *a1, ADDRESS *a2)
  * The function name may seem a little bit misleading: It checks all
  * recipients in To and Cc for known mailing lists, subscribed or not.
  */
-int mutt_is_list_cc(int alladdr, ADDRESS *a1, ADDRESS *a2)
+int mutt_is_list_cc(int alladdr, struct Address *a1, struct Address *a2)
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_mail_list(a1))
@@ -1377,7 +1377,7 @@ int mutt_is_list_cc(int alladdr, ADDRESS *a1, ADDRESS *a2)
   return alladdr;
 }
 
-static int match_user(int alladdr, ADDRESS *a1, ADDRESS *a2)
+static int match_user(int alladdr, struct Address *a1, struct Address *a2)
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_addr_is_user(a1))

diff --git a/pgp.c b/pgp.c
index f9badb11461babed9d046ca8b4e021df78a039f8..81e0fa6d7976bb7a62e9ae10187b229437293722 100644 (file)
--- a/pgp.c
+++ b/pgp.c
@@ -1184,14 +1184,14 @@ BODY *pgp_sign_message(BODY *a)
  * If oppenc_mode is true, only keys that can be determined without
  * prompting will be used.
  */
-char *pgp_find_keys(ADDRESS *adrlist, int oppenc_mode)
+char *pgp_find_keys(struct Address *adrlist, int oppenc_mode)
 {
   LIST *crypt_hook_list = NULL, *crypt_hook = NULL;
   char *keyID = NULL, *keylist = NULL;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
-  ADDRESS *addr = NULL;
-  ADDRESS *p = NULL, *q = NULL;
+  struct Address *addr = NULL;
+  struct Address *p = NULL, *q = NULL;
   pgp_key_t k_info = NULL;
   char buf[LONG_STRING];
   int r;

diff --git a/pgp.h b/pgp.h
index c9af9ece9d847b5d2ed9eeecdfb2b85d7c29a0e3..722a7f433da99864abd3c20aa8beba2db5dacdf5 100644 (file)
--- a/pgp.h
+++ b/pgp.h
@@ -44,10 +44,10 @@ int pgp_decrypt_mime(FILE *fpin, FILE **fpout, BODY *b, BODY **cur);
 
 pgp_key_t pgp_ask_for_key(char *tag, char *whatfor, short abilities, pgp_ring_t keyring);
 pgp_key_t pgp_get_candidates(pgp_ring_t keyring, LIST *hints);
-pgp_key_t pgp_getkeybyaddr(ADDRESS *a, short abilities, pgp_ring_t keyring, int oppenc_mode);
+pgp_key_t pgp_getkeybyaddr(struct Address *a, short abilities, pgp_ring_t keyring, int oppenc_mode);
 pgp_key_t pgp_getkeybystr(char *p, short abilities, pgp_ring_t keyring);
 
-char *pgp_find_keys(ADDRESS *adrlist, int oppenc_mode);
+char *pgp_find_keys(struct Address *adrlist, int oppenc_mode);
 
 int pgp_application_pgp_handler(BODY *m, STATE *s);
 int pgp_encrypted_handler(BODY *a, STATE *s);
@@ -81,7 +81,7 @@ pid_t pgp_invoke_traditional(FILE **pgpin, FILE **pgpout, FILE **pgperr,
 
 
 void pgp_invoke_import(const char *fname);
-void pgp_invoke_getkeys(ADDRESS *addr);
+void pgp_invoke_getkeys(struct Address *addr);
 
 
 /* private ? */

diff --git a/pgpinvoke.c b/pgpinvoke.c
index ebe015d3a21e2f71be4847ef3d01d88172d244a9..7743a9bc2bfbc792a8bae9cde233e1d6d193c788 100644 (file)
--- a/pgpinvoke.c
+++ b/pgpinvoke.c
@@ -252,7 +252,7 @@ void pgp_invoke_import(const char *fname)
   mutt_system(cmd);
 }
 
-void pgp_invoke_getkeys(ADDRESS *addr)
+void pgp_invoke_getkeys(struct Address *addr)
 {
   char buff[LONG_STRING];
   char tmp[LONG_STRING];

diff --git a/pgpkey.c b/pgpkey.c
index 91889d12b47d42eed456ca820098a001a9168a5e..0c26be89d74a2390064df27aeff837cca5230d7b 100644 (file)
--- a/pgpkey.c
+++ b/pgpkey.c
@@ -399,7 +399,7 @@ static bool pgp_id_is_valid(pgp_uid_t *uid)
 
 #define PGP_KV_MATCH (PGP_KV_ADDR | PGP_KV_STRING)
 
-static int pgp_id_matches_addr(ADDRESS *addr, ADDRESS *u_addr, pgp_uid_t *uid)
+static int pgp_id_matches_addr(struct Address *addr, struct Address *u_addr, pgp_uid_t *uid)
 {
   int rv = 0;
 
@@ -420,7 +420,7 @@ static int pgp_id_matches_addr(ADDRESS *addr, ADDRESS *u_addr, pgp_uid_t *uid)
   return rv;
 }
 
-static pgp_key_t pgp_select_key(pgp_key_t keys, ADDRESS *p, const char *s)
+static pgp_key_t pgp_select_key(pgp_key_t keys, struct Address *p, const char *s)
 {
   int keymax;
   pgp_uid_t **KeyTable;
@@ -782,9 +782,9 @@ static pgp_key_t *pgp_get_lastp(pgp_key_t p)
   return NULL;
 }
 
-pgp_key_t pgp_getkeybyaddr(ADDRESS *a, short abilities, pgp_ring_t keyring, int oppenc_mode)
+pgp_key_t pgp_getkeybyaddr(struct Address *a, short abilities, pgp_ring_t keyring, int oppenc_mode)
 {
-  ADDRESS *r = NULL, *p = NULL;
+  struct Address *r = NULL, *p = NULL;
   LIST *hints = NULL;
 
   int multi = 0;

diff --git a/protos.h b/protos.h
index 4a3d976cdb37ec7a0c313fd03c1b158a3ee9aa25..2ab8d19b52abbe3f231cf55c7559077badbb7fbf 100644 (file)
--- a/protos.h
+++ b/protos.h
@@ -92,13 +92,13 @@ int quadoption(int opt);
 
 char *mutt_extract_message_id(const char *s, const char **saveptr);
 
-ADDRESS *mutt_default_from(void);
-ADDRESS *mutt_get_address(ENVELOPE *env, char **pfxp);
-ADDRESS *mutt_lookup_alias(const char *s);
-ADDRESS *mutt_remove_duplicates(ADDRESS *addr);
-ADDRESS *mutt_remove_xrefs(ADDRESS *a, ADDRESS *b);
-ADDRESS *mutt_expand_aliases(ADDRESS *a);
-ADDRESS *mutt_parse_adrlist(ADDRESS *p, const char *s);
+struct Address *mutt_default_from(void);
+struct Address *mutt_get_address(ENVELOPE *env, char **pfxp);
+struct Address *mutt_lookup_alias(const char *s);
+struct Address *mutt_remove_duplicates(struct Address *addr);
+struct Address *mutt_remove_xrefs(struct Address *a, struct Address *b);
+struct Address *mutt_expand_aliases(struct Address *a);
+struct Address *mutt_parse_adrlist(struct Address *p, const char *s);
 
 BODY *mutt_make_file_attach(const char *path);
 BODY *mutt_make_message_attach(CONTEXT *ctx, HEADER *hdr, int attach_msg);
@@ -137,9 +137,9 @@ char *_mutt_expand_path(char *s, size_t slen, int rx);
 char *mutt_find_hook(int type, const char *pat);
 char *mutt_gecos_name(char *dest, size_t destlen, struct passwd *pw);
 char *mutt_get_body_charset(char *d, size_t dlen, BODY *b);
-const char *mutt_get_name(ADDRESS *a);
+const char *mutt_get_name(struct Address *a);
 char *mutt_get_parameter(const char *s, PARAMETER *p);
-LIST *mutt_crypt_hook(ADDRESS *adr);
+LIST *mutt_crypt_hook(struct Address *adr);
 char *mutt_make_date(char *s, size_t len);
 void mutt_timeout_hook(void);
 void mutt_startup_shutdown_hook(int type);
@@ -163,7 +163,7 @@ void mutt_attach_init(BODY *b);
 void mutt_block_signals(void);
 void mutt_block_signals_system(void);
 int mutt_body_handler(BODY *b, STATE *s);
-int mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to);
+int mutt_bounce_message(FILE *fp, HEADER *h, struct Address *to);
 void mutt_break_thread(HEADER *hdr);
 void mutt_buffy(char *s, size_t slen);
 int mutt_buffy_list(void);
@@ -172,7 +172,7 @@ int mutt_count_body_parts(CONTEXT *ctx, HEADER *hdr);
 void mutt_check_rescore(CONTEXT *ctx);
 void mutt_clear_error(void);
 void mutt_clear_pager_position(void);
-void mutt_create_alias(ENVELOPE *cur, ADDRESS *iadr);
+void mutt_create_alias(ENVELOPE *cur, struct Address *iadr);
 void mutt_decode_attachment(BODY *b, STATE *s);
 void mutt_decode_base64(STATE *s, long len, int istext, iconv_t cd);
 void mutt_default_save(char *path, size_t pathlen, HEADER *hdr);
@@ -241,8 +241,8 @@ void mutt_pipe_message(HEADER *h);
 void mutt_print_message(HEADER *h);
 void mutt_query_exit(void);
 void mutt_query_menu(char *buf, size_t buflen);
-void mutt_safe_path(char *s, size_t l, ADDRESS *a);
-void mutt_save_path(char *d, size_t dsize, ADDRESS *a);
+void mutt_safe_path(char *s, size_t l, struct Address *a);
+void mutt_save_path(char *d, size_t dsize, struct Address *a);
 void mutt_score_message(CONTEXT *ctx, HEADER *hdr, int upd_ctx);
 void mutt_select_fcc(char *path, size_t pathlen, HEADER *hdr);
 #define mutt_select_file(A, B, C) _mutt_select_file(A, B, C, NULL, NULL)
@@ -262,10 +262,10 @@ void mutt_unblock_signals_system(int catch);
 void mutt_update_encoding(BODY *a);
 void mutt_version(void);
 void mutt_view_attachments(HEADER *hdr);
-void mutt_write_address_list(ADDRESS *adr, FILE *fp, int linelen, int display);
+void mutt_write_address_list(struct Address *adr, FILE *fp, int linelen, int display);
 void mutt_set_virtual(CONTEXT *ctx);
 int mutt_add_to_rx_list(RX_LIST **list, const char *s, int flags, BUFFER *err);
-bool mutt_addr_is_user(ADDRESS *addr);
+bool mutt_addr_is_user(struct Address *addr);
 int mutt_addwch(wchar_t wc);
 int mutt_alias_complete(char *s, size_t buflen);
 void mutt_alias_add_reverse(ALIAS *t);
@@ -324,13 +324,13 @@ int mutt_get_field_unbuffered(char *msg, char *buf, size_t buflen, int flags);
 int mutt_get_postponed(CONTEXT *ctx, HEADER *hdr, HEADER **cur, char *fcc, size_t fcclen);
 int mutt_get_tmp_attachment(BODY *a);
 int mutt_index_menu(void);
-int mutt_invoke_sendmail(ADDRESS *from, ADDRESS *to, ADDRESS *cc, ADDRESS *bcc,
+int mutt_invoke_sendmail(struct Address *from, struct Address *to, struct Address *cc, struct Address *bcc,
                          const char *msg, int eightbit);
-bool mutt_is_mail_list(ADDRESS *addr);
+bool mutt_is_mail_list(struct Address *addr);
 bool mutt_is_message_type(int type, const char *subtype);
-int mutt_is_list_cc(int alladdr, ADDRESS *a1, ADDRESS *a2);
-int mutt_is_list_recipient(int alladdr, ADDRESS *a1, ADDRESS *a2);
-bool mutt_is_subscribed_list(ADDRESS *addr);
+int mutt_is_list_cc(int alladdr, struct Address *a1, struct Address *a2);
+int mutt_is_list_recipient(int alladdr, struct Address *a1, struct Address *a2);
+bool mutt_is_subscribed_list(struct Address *addr);
 bool mutt_is_text_part(BODY *b);
 int mutt_link_threads(HEADER *cur, HEADER *last, CONTEXT *ctx);
 int mutt_lookup_mime_type(BODY *att, const char *path);
@@ -366,8 +366,8 @@ int _mutt_save_message(HEADER *h, CONTEXT *ctx, int delete, int decode, int decr
 int mutt_save_message(HEADER *h, int delete, int decode, int decrypt);
 int mutt_search_command(int cur, int op);
 #ifdef USE_SMTP
-int mutt_smtp_send(const ADDRESS *from, const ADDRESS *to, const ADDRESS *cc,
-                   const ADDRESS *bcc, const char *msgfile, int eightbit);
+int mutt_smtp_send(const struct Address *from, const struct Address *to, const struct Address *cc,
+                   const struct Address *bcc, const char *msgfile, int eightbit);
 #endif
 
 size_t mutt_wstr_trunc(const char *src, size_t maxlen, size_t maxwid, size_t *width);
@@ -401,7 +401,7 @@ uint32_t mutt_rand32(void);
 uint64_t mutt_rand64(void);
 
 
-ADDRESS *alias_reverse_lookup(ADDRESS *a);
+struct Address *alias_reverse_lookup(struct Address *a);
 
 /* base64.c */
 size_t mutt_to_base64(char *out, const char *cin, size_t len, size_t olen);

diff --git a/query.c b/query.c
index f6505427364f32c17d38cc0cf3fcedf7c3f586a7..f5c29b81efe1c711640997e842c6ba24156afa84 100644 (file)
--- a/query.c
+++ b/query.c
@@ -28,7 +28,7 @@
 typedef struct query
 {
   int num;
-  ADDRESS *addr;
+  struct Address *addr;
   char *name;
   char *other;
   struct query *next;
@@ -50,9 +50,9 @@ static const struct mapping_t QueryHelp[] = {
   { NULL, 0 },
 };
 
-static ADDRESS *result_to_addr(QUERY *r)
+static struct Address *result_to_addr(QUERY *r)
 {
-  static ADDRESS *tmp = NULL;
+  static struct Address *tmp = NULL;
 
   if (!(tmp = rfc822_cpy_adr(r->addr, 0)))
     return NULL;
@@ -371,12 +371,12 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
         case OP_CREATE_ALIAS:
           if (menu->tagprefix)
           {
-            ADDRESS *naddr = NULL;
+            struct Address *naddr = NULL;
 
             for (i = 0; i < menu->max; i++)
               if (QueryTable[i].tagged)
               {
-                ADDRESS *a = result_to_addr(QueryTable[i].data);
+                struct Address *a = result_to_addr(QueryTable[i].data);
                 rfc822_append(&naddr, a, 0);
                 rfc822_free_address(&a);
               }
@@ -386,7 +386,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
           }
           else
           {
-            ADDRESS *a = result_to_addr(QueryTable[menu->current].data);
+            struct Address *a = result_to_addr(QueryTable[menu->current].data);
             mutt_create_alias(NULL, a);
             rfc822_free_address(&a);
           }
@@ -412,7 +412,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
             for (i = 0; i < menu->max; i++)
               if (QueryTable[i].tagged)
               {
-                ADDRESS *a = result_to_addr(QueryTable[i].data);
+                struct Address *a = result_to_addr(QueryTable[i].data);
                 rfc822_append(&msg->env->to, a, 0);
                 rfc822_free_address(&a);
               }
@@ -442,7 +442,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
         {
           if (curpos == 0)
           {
-            ADDRESS *tmpa = result_to_addr(QueryTable[i].data);
+            struct Address *tmpa = result_to_addr(QueryTable[i].data);
             mutt_addrlist_to_local(tmpa);
             tagged = 1;
             rfc822_write_address(buf, buflen, tmpa, 0);
@@ -451,7 +451,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
           }
           else if (curpos + 2 < buflen)
           {
-            ADDRESS *tmpa = result_to_addr(QueryTable[i].data);
+            struct Address *tmpa = result_to_addr(QueryTable[i].data);
             mutt_addrlist_to_local(tmpa);
             strcat(buf, ", ");
             rfc822_write_address((char *) buf + curpos + 1, buflen - curpos - 1, tmpa, 0);
@@ -463,7 +463,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
       /* then enter current message */
       if (!tagged)
       {
-        ADDRESS *tmpa = result_to_addr(QueryTable[menu->current].data);
+        struct Address *tmpa = result_to_addr(QueryTable[menu->current].data);
         mutt_addrlist_to_local(tmpa);
         rfc822_write_address(buf, buflen, tmpa, 0);
         rfc822_free_address(&tmpa);
@@ -479,7 +479,7 @@ static void query_menu(char *buf, size_t buflen, QUERY *results, int retbuf)
 int mutt_query_complete(char *buf, size_t buflen)
 {
   QUERY *results = NULL;
-  ADDRESS *tmpa = NULL;
+  struct Address *tmpa = NULL;
 
   if (!QueryCmd)
   {

diff --git a/recvcmd.c b/recvcmd.c
index aab5d3ab6dce9f668d928acd8120059032bb9626..e7aedde88c25b08e0950e021706e1fee9b0454c4 100644 (file)
--- a/recvcmd.c
+++ b/recvcmd.c
@@ -113,7 +113,7 @@ void mutt_attach_bounce(FILE *fp, HEADER *hdr, ATTACHPTR **idx, short idxlen, BO
   char prompt[STRING];
   char buf[HUGE_STRING];
   char *err = NULL;
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
   int ret = 0;
   int p = 0;
 

diff --git a/remailer.c b/remailer.c
index dca61ccde64d499cc077610e84dfdfdb9d1cf3e9..31be3c4d25af379425a56dc4d601440424fccf10 100644 (file)
--- a/remailer.c
+++ b/remailer.c
@@ -650,7 +650,7 @@ int mix_check_message(HEADER *msg)
 {
   const char *fqdn = NULL;
   short need_hostname = 0;
-  ADDRESS *p = NULL;
+  struct Address *p = NULL;
 
   if (msg->env->cc || msg->env->bcc)
   {

diff --git a/rfc2047.c b/rfc2047.c
index 78b0e8241f3c84bf947f06b2ca63aeb7226eab99..2f3c386073608a88eb3476444c443d77ef0bec1d 100644 (file)
--- a/rfc2047.c
+++ b/rfc2047.c
@@ -576,9 +576,9 @@ void _rfc2047_encode_string(char **pd, int encode_specials, int col)
   *pd = e;
 }
 
-void rfc2047_encode_adrlist(ADDRESS *addr, const char *tag)
+void rfc2047_encode_adrlist(struct Address *addr, const char *tag)
 {
-  ADDRESS *ptr = addr;
+  struct Address *ptr = addr;
   int col = tag ? strlen(tag) + 2 : 32;
 
   while (ptr)
@@ -873,7 +873,7 @@ void rfc2047_decode(char **pd)
   mutt_str_adjust(pd);
 }
 
-void rfc2047_decode_adrlist(ADDRESS *a)
+void rfc2047_decode_adrlist(struct Address *a)
 {
   while (a)
   {

diff --git a/rfc2047.h b/rfc2047.h
index d045bfb7a29c92df01503fcf5804f9c23bc336a2..28152b6c42f3d1ba5ca8a4e01ccef5bf5522617d 100644 (file)
--- a/rfc2047.h
+++ b/rfc2047.h
@@ -23,11 +23,11 @@ char *mutt_choose_charset(const char *fromcode, const char *charsets, char *u,
 int convert_nonmime_string(char **ps);
 
 void _rfc2047_encode_string(char **pd, int encode_specials, int col);
-void rfc2047_encode_adrlist(ADDRESS *addr, const char *tag);
+void rfc2047_encode_adrlist(struct Address *addr, const char *tag);
 
 #define rfc2047_encode_string(a) _rfc2047_encode_string(a, 0, 32);
 
 void rfc2047_decode(char **pd);
-void rfc2047_decode_adrlist(ADDRESS *a);
+void rfc2047_decode_adrlist(struct Address *a);
 
 #endif /* _MUTT_RFC2047_H */

diff --git a/rfc822.c b/rfc822.c
index 032aa472210b0b92a10010c9a6d0b6b799ed2f89..b41a95279400312ee270cb75c966258e136941e9 100644 (file)
--- a/rfc822.c
+++ b/rfc822.c
@@ -85,7 +85,7 @@ void rfc822_dequote_comment(char *s)
   *w = 0;
 }
 
-static void free_address(ADDRESS *a)
+static void free_address(struct Address *a)
 {
   FREE(&a->personal);
   FREE(&a->mailbox);
@@ -95,9 +95,9 @@ static void free_address(ADDRESS *a)
   FREE(&a);
 }
 
-int rfc822_remove_from_adrlist(ADDRESS **a, const char *mailbox)
+int rfc822_remove_from_adrlist(struct Address **a, const char *mailbox)
 {
-  ADDRESS *p = NULL, *last = NULL, *t = NULL;
+  struct Address *p = NULL, *last = NULL, *t = NULL;
   int rv = -1;
 
   p = *a;
@@ -125,9 +125,9 @@ int rfc822_remove_from_adrlist(ADDRESS **a, const char *mailbox)
   return rv;
 }
 
-void rfc822_free_address(ADDRESS **p)
+void rfc822_free_address(struct Address **p)
 {
-  ADDRESS *t = NULL;
+  struct Address *t = NULL;
 
   while (*p)
   {
@@ -255,7 +255,7 @@ static const char *parse_mailboxdomain(const char *s, const char *nonspecial,
 
 static const char *parse_address(const char *s, char *token, size_t *tokenlen,
                                  size_t tokenmax, char *comment, size_t *commentlen,
-                                 size_t commentmax, ADDRESS *addr)
+                                 size_t commentmax, struct Address *addr)
 {
   s = parse_mailboxdomain(s, ".\"(\\", token, tokenlen, tokenmax, comment,
                           commentlen, commentmax);
@@ -285,7 +285,7 @@ static const char *parse_address(const char *s, char *token, size_t *tokenlen,
 }
 
 static const char *parse_route_addr(const char *s, char *comment, size_t *commentlen,
-                                    size_t commentmax, ADDRESS *addr)
+                                    size_t commentmax, struct Address *addr)
 {
   char token[LONG_STRING];
   size_t tokenlen = 0;
@@ -331,7 +331,7 @@ static const char *parse_route_addr(const char *s, char *comment, size_t *commen
 }
 
 static const char *parse_addr_spec(const char *s, char *comment, size_t *commentlen,
-                                   size_t commentmax, ADDRESS *addr)
+                                   size_t commentmax, struct Address *addr)
 {
   char token[LONG_STRING];
   size_t tokenlen = 0;
@@ -346,10 +346,10 @@ static const char *parse_addr_spec(const char *s, char *comment, size_t *comment
   return s;
 }
 
-static void add_addrspec(ADDRESS **top, ADDRESS **last, const char *phrase,
+static void add_addrspec(struct Address **top, struct Address **last, const char *phrase,
                          char *comment, size_t *commentlen, size_t commentmax)
 {
-  ADDRESS *cur = rfc822_new_address();
+  struct Address *cur = rfc822_new_address();
 
   if (parse_addr_spec(phrase, comment, commentlen, commentmax, cur) == NULL)
   {
@@ -364,7 +364,7 @@ static void add_addrspec(ADDRESS **top, ADDRESS **last, const char *phrase,
   *last = cur;
 }
 
-ADDRESS *rfc822_parse_adrlist(ADDRESS *top, const char *s)
+struct Address *rfc822_parse_adrlist(struct Address *top, const char *s)
 {
   int ws_pending, nl;
 #ifdef EXACT_ADDRESS
@@ -373,7 +373,7 @@ ADDRESS *rfc822_parse_adrlist(ADDRESS *top, const char *s)
   const char *ps = NULL;
   char comment[LONG_STRING], phrase[LONG_STRING];
   size_t phraselen = 0, commentlen = 0;
-  ADDRESS *cur = NULL, *last = NULL;
+  struct Address *cur = NULL, *last = NULL;
 
   RFC822Error = 0;
 
@@ -550,7 +550,7 @@ ADDRESS *rfc822_parse_adrlist(ADDRESS *top, const char *s)
   return top;
 }
 
-void rfc822_qualify(ADDRESS *addr, const char *host)
+void rfc822_qualify(struct Address *addr, const char *host)
 {
   char *p = NULL;
 
@@ -590,7 +590,7 @@ void rfc822_cat(char *buf, size_t buflen, const char *value, const char *special
     strfcpy(buf, value, buflen);
 }
 
-void rfc822_write_address_single(char *buf, size_t buflen, ADDRESS *addr, int display)
+void rfc822_write_address_single(char *buf, size_t buflen, struct Address *addr, int display)
 {
   size_t len;
   char *pbuf = buf;
@@ -727,7 +727,7 @@ done:
 }
 
 /* note: it is assumed that `buf' is nul terminated! */
-int rfc822_write_address(char *buf, size_t buflen, ADDRESS *addr, int display)
+int rfc822_write_address(char *buf, size_t buflen, struct Address *addr, int display)
 {
   char *pbuf = buf;
   size_t len = mutt_strlen(buf);
@@ -783,9 +783,9 @@ done:
 }
 
 /* this should be rfc822_cpy_adr */
-ADDRESS *rfc822_cpy_adr_real(ADDRESS *addr)
+struct Address *rfc822_cpy_adr_real(struct Address *addr)
 {
-  ADDRESS *p = rfc822_new_address();
+  struct Address *p = rfc822_new_address();
 
 #ifdef EXACT_ADDRESS
   p->val = safe_strdup(addr->val);
@@ -799,9 +799,9 @@ ADDRESS *rfc822_cpy_adr_real(ADDRESS *addr)
 }
 
 /* this should be rfc822_cpy_adrlist */
-ADDRESS *rfc822_cpy_adr(ADDRESS *addr, int prune)
+struct Address *rfc822_cpy_adr(struct Address *addr, int prune)
 {
-  ADDRESS *top = NULL, *last = NULL;
+  struct Address *top = NULL, *last = NULL;
 
   for (; addr; addr = addr->next)
   {
@@ -821,9 +821,9 @@ ADDRESS *rfc822_cpy_adr(ADDRESS *addr, int prune)
 }
 
 /* append list 'b' to list 'a' and return the last element in the new list */
-ADDRESS *rfc822_append(ADDRESS **a, ADDRESS *b, int prune)
+struct Address *rfc822_append(struct Address **a, struct Address *b, int prune)
 {
-  ADDRESS *tmp = *a;
+  struct Address *tmp = *a;
 
   while (tmp && tmp->next)
     tmp = tmp->next;
@@ -892,7 +892,7 @@ int safe_free(void **p)
 
 int main(int argc, char **argv)
 {
-  ADDRESS *list = NULL;
+  struct Address *list = NULL;
   char buf[256];
   char *str = "a b c ";
 

diff --git a/rfc822.h b/rfc822.h
index 47190931daa869b26026b0cbfcec1b477933d118..7a985a70ec4d3a1fe789de6130083cadcaf583f3 100644 (file)
--- a/rfc822.h
+++ b/rfc822.h
@@ -32,7 +32,7 @@ enum
   ERR_BAD_ADDR_SPEC
 };
 
-typedef struct address_t
+struct Address
 {
 #ifdef EXACT_ADDRESS
   char *val;      /* value of address as parsed */
@@ -40,33 +40,33 @@ typedef struct address_t
   char *personal; /* real name of address */
   char *mailbox;  /* mailbox and host address */
   int group;      /* group mailbox? */
-  struct address_t *next;
+  struct Address *next;
   bool is_intl : 1;
   bool intl_checked : 1;
-} ADDRESS;
+};
 
 void rfc822_dequote_comment(char *s);
-void rfc822_free_address(ADDRESS **p);
-void rfc822_qualify(ADDRESS *addr, const char *host);
-ADDRESS *rfc822_parse_adrlist(ADDRESS *top, const char *s);
-ADDRESS *rfc822_cpy_adr(ADDRESS *addr, int prune);
-ADDRESS *rfc822_cpy_adr_real(ADDRESS *addr);
-ADDRESS *rfc822_append(ADDRESS **a, ADDRESS *b, int prune);
-int rfc822_write_address(char *buf, size_t buflen, ADDRESS *addr, int display);
-void rfc822_write_address_single(char *buf, size_t buflen, ADDRESS *addr, int display);
-void rfc822_free_address(ADDRESS **p);
+void rfc822_free_address(struct Address **p);
+void rfc822_qualify(struct Address *addr, const char *host);
+struct Address *rfc822_parse_adrlist(struct Address *top, const char *s);
+struct Address *rfc822_cpy_adr(struct Address *addr, int prune);
+struct Address *rfc822_cpy_adr_real(struct Address *addr);
+struct Address *rfc822_append(struct Address **a, struct Address *b, int prune);
+int rfc822_write_address(char *buf, size_t buflen, struct Address *addr, int display);
+void rfc822_write_address_single(char *buf, size_t buflen, struct Address *addr, int display);
+void rfc822_free_address(struct Address **p);
 void rfc822_cat(char *buf, size_t buflen, const char *value, const char *specials);
 bool rfc822_valid_msgid(const char *msgid);
-int rfc822_remove_from_adrlist(ADDRESS **a, const char *mailbox);
+int rfc822_remove_from_adrlist(struct Address **a, const char *mailbox);
 
 extern int RFC822Error;
 extern const char *const RFC822Errors[];
 
 #define rfc822_error(x) RFC822Errors[x]
 
-static inline ADDRESS *rfc822_new_address(void)
+static inline struct Address *rfc822_new_address(void)
 {
-  return safe_calloc(1, sizeof(ADDRESS));
+  return safe_calloc(1, sizeof(struct Address));
 }
 
 #endif /* _MUTT_RFC822_H */

diff --git a/send.c b/send.c
index a62cde2fd30219fd9010f6578d32a10804a861d3..d879accae21ba0fb43729e7362daf2f606ff23ee 100644 (file)
--- a/send.c
+++ b/send.c
@@ -68,7 +68,7 @@ static void append_signature(FILE *f)
 }
 
 /* compare two e-mail addresses and return 1 if they are equivalent */
-static bool addrcmp(ADDRESS *a, ADDRESS *b)
+static bool addrcmp(struct Address *a, struct Address *b)
 {
   if (!a->mailbox || !b->mailbox)
     return false;
@@ -78,7 +78,7 @@ static bool addrcmp(ADDRESS *a, ADDRESS *b)
 }
 
 /* search an e-mail address in a list */
-static int addrsrc(ADDRESS *a, ADDRESS *lst)
+static int addrsrc(struct Address *a, struct Address *lst)
 {
   for (; lst; lst = lst->next)
   {
@@ -89,9 +89,9 @@ static int addrsrc(ADDRESS *a, ADDRESS *lst)
 }
 
 /* removes addresses from "b" which are contained in "a" */
-ADDRESS *mutt_remove_xrefs(ADDRESS *a, ADDRESS *b)
+struct Address *mutt_remove_xrefs(struct Address *a, struct Address *b)
 {
-  ADDRESS *top = NULL, *p = NULL, *prev = NULL;
+  struct Address *top = NULL, *p = NULL, *prev = NULL;
 
   top = b;
   while (b)
@@ -130,9 +130,9 @@ ADDRESS *mutt_remove_xrefs(ADDRESS *a, ADDRESS *b)
 /* remove any address which matches the current user.  if `leave_only' is
  * nonzero, don't remove the user's address if it is the only one in the list
  */
-static ADDRESS *remove_user(ADDRESS *a, int leave_only)
+static struct Address *remove_user(struct Address *a, int leave_only)
 {
-  ADDRESS *top = NULL, *last = NULL;
+  struct Address *top = NULL, *last = NULL;
 
   while (a)
   {
@@ -150,7 +150,7 @@ static ADDRESS *remove_user(ADDRESS *a, int leave_only)
     }
     else
     {
-      ADDRESS *tmp = a;
+      struct Address *tmp = a;
 
       a = a->next;
       if (!leave_only || a || last)
@@ -165,9 +165,9 @@ static ADDRESS *remove_user(ADDRESS *a, int leave_only)
   return top;
 }
 
-static ADDRESS *find_mailing_lists(ADDRESS *t, ADDRESS *c)
+static struct Address *find_mailing_lists(struct Address *t, struct Address *c)
 {
-  ADDRESS *top = NULL, *ptr = NULL;
+  struct Address *top = NULL, *ptr = NULL;
 
   for (; t || c; t = c, c = NULL)
   {
@@ -188,7 +188,7 @@ static ADDRESS *find_mailing_lists(ADDRESS *t, ADDRESS *c)
   return top;
 }
 
-static int edit_address(ADDRESS **a, /* const */ char *field)
+static int edit_address(struct Address **a, /* const */ char *field)
 {
   char buf[HUGE_STRING];
   char *err = NULL;
@@ -495,7 +495,7 @@ static int include_reply(CONTEXT *ctx, HEADER *cur, FILE *out)
   return 0;
 }
 
-static int default_to(ADDRESS **to, ENVELOPE *env, int flags, int hmfupto)
+static int default_to(struct Address **to, ENVELOPE *env, int flags, int hmfupto)
 {
   char prompt[STRING];
 
@@ -572,7 +572,7 @@ static int default_to(ADDRESS **to, ENVELOPE *env, int flags, int hmfupto)
 int mutt_fetch_recips(ENVELOPE *out, ENVELOPE *in, int flags)
 {
   char prompt[STRING];
-  ADDRESS *tmp = NULL;
+  struct Address *tmp = NULL;
   int hmfupto = -1;
 
   if ((flags & (SENDLISTREPLY | SENDGROUPREPLY)) && in->mail_followup_to)
@@ -933,8 +933,8 @@ static int generate_body(FILE *tempfp, /* stream for outgoing message */
 
 void mutt_set_followup_to(ENVELOPE *e)
 {
-  ADDRESS *t = NULL;
-  ADDRESS *from = NULL;
+  struct Address *t = NULL;
+  struct Address *from = NULL;
 
   /*
    * Only generate the Mail-Followup-To if the user has requested it, and
@@ -1003,9 +1003,9 @@ void mutt_set_followup_to(ENVELOPE *e)
 /* look through the recipients of the message we are replying to, and if
    we find an address that matches $alternates, we use that as the default
    from field */
-static ADDRESS *set_reverse_name(ENVELOPE *env)
+static struct Address *set_reverse_name(ENVELOPE *env)
 {
-  ADDRESS *tmp = NULL;
+  struct Address *tmp = NULL;
 
   for (tmp = env->to; tmp; tmp = tmp->next)
   {
@@ -1034,9 +1034,9 @@ static ADDRESS *set_reverse_name(ENVELOPE *env)
   return tmp;
 }
 
-ADDRESS *mutt_default_from(void)
+struct Address *mutt_default_from(void)
 {
-  ADDRESS *adr = NULL;
+  struct Address *adr = NULL;
   const char *fqdn = mutt_fqdn(1);
 
   /*
@@ -1236,7 +1236,7 @@ static int is_reply(HEADER *reply, HEADER *orig)
          mutt_find_list(orig->env->in_reply_to, reply->env->message_id);
 }
 
-static int has_recips(ADDRESS *a)
+static int has_recips(struct Address *a)
 {
   int c = 0;
 

diff --git a/sendlib.c b/sendlib.c
index fd0657d12b165f8daa6690efe1431d585f1cde00..b392669d6f18c98a25519a200235e520f4331c10 100644 (file)
--- a/sendlib.c
+++ b/sendlib.c
@@ -1461,9 +1461,9 @@ char *mutt_make_date(char *s, size_t len)
 
 /* wrapper around mutt_write_address() so we can handle very large
    recipient lists without needing a huge temporary buffer in memory */
-void mutt_write_address_list(ADDRESS *adr, FILE *fp, int linelen, int display)
+void mutt_write_address_list(struct Address *adr, FILE *fp, int linelen, int display)
 {
-  ADDRESS *tmp = NULL;
+  struct Address *tmp = NULL;
   char buf[LONG_STRING];
   int count = 0;
   int len;
@@ -2326,7 +2326,7 @@ static int send_msg(const char *path, char **args, const char *msg, char **tempf
   return st;
 }
 
-static char **add_args(char **args, size_t *argslen, size_t *argsmax, ADDRESS *addr)
+static char **add_args(char **args, size_t *argslen, size_t *argsmax, struct Address *addr)
 {
   for (; addr; addr = addr->next)
   {
@@ -2349,8 +2349,8 @@ static char **add_option(char **args, size_t *argslen, size_t *argsmax, char *s)
   return args;
 }
 
-int mutt_invoke_sendmail(ADDRESS *from, /* the sender */
-                         ADDRESS *to, ADDRESS *cc, ADDRESS *bcc, /* recips */
+int mutt_invoke_sendmail(struct Address *from, /* the sender */
+                         struct Address *to, struct Address *cc, struct Address *bcc, /* recips */
                          const char *msg, /* file containing message */
                          int eightbit)    /* message contains 8bit chars */
 {
@@ -2576,8 +2576,8 @@ void mutt_unprepare_envelope(ENVELOPE *env)
   rfc2047_decode(&env->subject);
 }
 
-static int _mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to,
-                                const char *resent_from, ADDRESS *env_from)
+static int _mutt_bounce_message(FILE *fp, HEADER *h, struct Address *to,
+                                const char *resent_from, struct Address *env_from)
 {
   int i, ret = 0;
   FILE *f = NULL;
@@ -2641,9 +2641,9 @@ static int _mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to,
   return ret;
 }
 
-int mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to)
+int mutt_bounce_message(FILE *fp, HEADER *h, struct Address *to)
 {
-  ADDRESS *from = NULL, *resent_to = NULL;
+  struct Address *from = NULL, *resent_to = NULL;
   const char *fqdn = mutt_fqdn(1);
   char resent_from[STRING];
   int ret;
@@ -2696,11 +2696,11 @@ int mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to)
 
 
 /* given a list of addresses, return a list of unique addresses */
-ADDRESS *mutt_remove_duplicates(ADDRESS *addr)
+struct Address *mutt_remove_duplicates(struct Address *addr)
 {
-  ADDRESS *top = addr;
-  ADDRESS **last = ⊤
-  ADDRESS *tmp = NULL;
+  struct Address *top = addr;
+  struct Address **last = ⊤
+  struct Address *tmp = NULL;
   int dup;
 
   while (addr)

diff --git a/smime.c b/smime.c
index 66ad74be31ae7f07fd49ad64db0bf0c36cb7e08a..d1d3979aff836391fd20655cddd08091d5d4de25 100644 (file)
--- a/smime.c
+++ b/smime.c
@@ -801,7 +801,7 @@ static void _smime_getkeys(char *mailbox)
 
 void smime_getkeys(ENVELOPE *env)
 {
-  ADDRESS *t = NULL;
+  struct Address *t = NULL;
   int found = 0;
 
   if (option(OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey)
@@ -838,13 +838,13 @@ void smime_getkeys(ENVELOPE *env)
  * If oppenc_mode is true, only keys that can be determined without
  * prompting will be used.
  */
-char *smime_find_keys(ADDRESS *adrlist, int oppenc_mode)
+char *smime_find_keys(struct Address *adrlist, int oppenc_mode)
 {
   smime_key_t *key = NULL;
   char *keyID = NULL, *keylist = NULL;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
-  ADDRESS *p = NULL, *q = NULL;
+  struct Address *p = NULL, *q = NULL;
 
   for (p = adrlist; p; p = p->next)
   {

diff --git a/smime.h b/smime.h
index ac80413cd463590c88d975d72c0aefbdfdbc7c3d..ec105b3e7f16901ea767271a675487f4733afc34 100644 (file)
--- a/smime.h
+++ b/smime.h
@@ -54,7 +54,7 @@ int smime_verify_sender(HEADER *h);
 
 void smime_getkeys(ENVELOPE *env);
 
-char *smime_find_keys(ADDRESS *adrlist, int oppenc_mode);
+char *smime_find_keys(struct Address *adrlist, int oppenc_mode);
 
 void smime_invoke_import(char *infile, char *mailbox);
 

diff --git a/smtp.c b/smtp.c
index 066d9e43c1e09f3abbd29ca6fa7f6fd0544c6ad9..2293c74a276505d3612e22fc50dfc8fbd08638e7 100644 (file)
--- a/smtp.c
+++ b/smtp.c
@@ -128,7 +128,7 @@ static int smtp_get_resp(CONNECTION *conn)
   return -1;
 }
 
-static int smtp_rcpt_to(CONNECTION *conn, const ADDRESS *a)
+static int smtp_rcpt_to(CONNECTION *conn, const struct Address *a)
 {
   char buf[1024];
   int r;
@@ -247,7 +247,7 @@ static bool address_uses_unicode(const char *a)
 /* Returns 1 if any address in a contains at least one 8-bit
  * character, 0 if none do.
  */
-static bool addresses_use_unicode(const ADDRESS *a)
+static bool addresses_use_unicode(const struct Address *a)
 {
   while (a)
   {
@@ -614,8 +614,8 @@ static int smtp_open(CONNECTION *conn)
   return 0;
 }
 
-int mutt_smtp_send(const ADDRESS *from, const ADDRESS *to, const ADDRESS *cc,
-                   const ADDRESS *bcc, const char *msgfile, int eightbit)
+int mutt_smtp_send(const struct Address *from, const struct Address *to, const struct Address *cc,
+                   const struct Address *bcc, const char *msgfile, int eightbit)
 {
   CONNECTION *conn = NULL;
   struct Account account;

diff --git a/sort.c b/sort.c
index d16062226bb4003bc064ee7453cef181bb699eae..5ae8bdbcd00b49ddb4eca70f7379c97f913bd535 100644 (file)
--- a/sort.c
+++ b/sort.c
@@ -91,9 +91,9 @@ static int compare_subject(const void *a, const void *b)
   return (SORTCODE(rc));
 }
 
-const char *mutt_get_name(ADDRESS *a)
+const char *mutt_get_name(struct Address *a)
 {
-  ADDRESS *ali = NULL;
+  struct Address *ali = NULL;
 
   if (a)
   {