doxy: tidy list comments

diff --git a/alias.h b/alias.h
index f6af84d3a9408d4e313bd2a930903f0f6221b085..768407f9323fb2df2820327629d4b31f8e500547 100644 (file)
--- a/alias.h
+++ b/alias.h
@@ -36,12 +36,12 @@ struct Envelope;
  */
 struct Alias
 {
-  char *name;
-  struct AddressList addr;
-  bool tagged;
-  bool del;
-  short num;
-  TAILQ_ENTRY(Alias) entries;
+  char *name;                 ///< Short name
+  struct AddressList addr;    ///< List of Addresses the Alias expands to
+  bool tagged;                ///< Is it tagged?
+  bool del;                   ///< Is it deleted?
+  short num;                  ///< Index number in list
+  TAILQ_ENTRY(Alias) entries; ///< Linked list
 };
 TAILQ_HEAD(AliasList, Alias);
 

diff --git a/email/tags.h b/email/tags.h
index 3a5653706a4b3078834a714734418cbc0e572210..6e3aa518c5255efa3f8e6af5d6bed7fce9cef033 100644 (file)
--- a/email/tags.h
+++ b/email/tags.h
@@ -39,9 +39,9 @@ extern struct Hash *TagTransforms;
  */
 struct Tag
 {
-  char *name;                    ///< Tag name
-  char *transformed;             ///< Transformed name
-  bool hidden;                   ///< Tag should be hidden
+  char *name;                ///< Tag name
+  char *transformed;         ///< Transformed name
+  bool hidden;               ///< Tag should be hidden
   STAILQ_ENTRY(Tag) entries; ///< Linked list
 };
 STAILQ_HEAD(TagList, Tag);

diff --git a/hook.c b/hook.c
index f182a0b84cf639d7f06eab1a7e9769a54c10788a..65198f04df476488c2b393dc16ae8b9bed40338b 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -68,7 +68,7 @@ struct Hook
   struct Regex regex;          ///< Regular expression
   char *command;               ///< Filename, command or pattern to execute
   struct PatternList *pattern; ///< Used for fcc,save,send-hook
-  TAILQ_ENTRY(Hook) entries;
+  TAILQ_ENTRY(Hook) entries;   ///< Linked list
 };
 TAILQ_HEAD(HookList, Hook);
 

diff --git a/mutt/charset.c b/mutt/charset.c
index 2f9c636cd8a4d42ca7deea2792d9f092d232749c..f6e89385eb0a0499d64e723318245ccbc6245da4 100644 (file)
--- a/mutt/charset.c
+++ b/mutt/charset.c
@@ -70,10 +70,10 @@ bool CharsetIsUtf8 = false;
  */
 struct Lookup
 {
-  enum LookupType type; /**< Lookup type */
-  struct Regex regex;   /**< Regular expression */
-  char *replacement;    /**< Alternative charset to use */
-  TAILQ_ENTRY(Lookup) entries;
+  enum LookupType type;        ///< Lookup type
+  struct Regex regex;          ///< Regular expression
+  char *replacement;           ///< Alternative charset to use
+  TAILQ_ENTRY(Lookup) entries; ///< Linked list
 };
 TAILQ_HEAD(LookupList, Lookup);
 

diff --git a/mutt/list.h b/mutt/list.h
index 3ee70a57c5b8060fd7d52607ec94ad3fdbccf8c9..4d8f413ec0113286c37fd22e15f93a521b91397d 100644 (file)
--- a/mutt/list.h
+++ b/mutt/list.h
@@ -32,8 +32,8 @@
  */
 struct ListNode
 {
-  char *data;
-  STAILQ_ENTRY(ListNode) entries;
+  char *data;                     ///< String
+  STAILQ_ENTRY(ListNode) entries; ///< Linked list
 };
 STAILQ_HEAD(ListHead, ListNode);
 

diff --git a/mutt/logging.h b/mutt/logging.h
index d48afc439ce65d09f93001e74d4d036ea156b982..bbd1822fdaa59302f0347f96af61aaa97ba4463e 100644 (file)
--- a/mutt/logging.h
+++ b/mutt/logging.h
@@ -68,13 +68,13 @@ enum LogLevel
  */
 struct LogLine
 {
-  time_t time;
-  const char *file;
-  int line;
-  const char *function;
-  int level;
-  char *message;
-  STAILQ_ENTRY(LogLine) entries;
+  time_t time;                   ///< Timestamp of the message
+  const char *file;              ///< Source file
+  int line;                      ///< Line number in source file
+  const char *function;          ///< C function
+  int level;                     ///< Log level, e.g. #LL_DEBUG1
+  char *message;                 ///< Message to be logged
+  STAILQ_ENTRY(LogLine) entries; ///< Linked list
 };
 STAILQ_HEAD(LogLineList, LogLine);
 

diff --git a/mutt/observer.h b/mutt/observer.h
index d6ddaac2b2cb80bd7780919780cc98aa699ee7c9..6fe75fcc2a48999501645479bfe23c06e8c0a4a4 100644 (file)
--- a/mutt/observer.h
+++ b/mutt/observer.h
@@ -76,8 +76,8 @@ struct Observer
  */
 struct ObserverNode
 {
-  struct Observer *observer;
-  STAILQ_ENTRY(ObserverNode) entries;
+  struct Observer *observer;          ///< An Observer
+  STAILQ_ENTRY(ObserverNode) entries; ///< Linked list
 };
 STAILQ_HEAD(ObserverList, ObserverNode);
 

diff --git a/mutt/regex3.h b/mutt/regex3.h
index 976578a4329fe5c3b9e047dcc2594946af7dd954..b178fbab1b975c5320db8626015b7ed70b29ef1f 100644 (file)
--- a/mutt/regex3.h
+++ b/mutt/regex3.h
@@ -66,8 +66,8 @@ struct Regex
  */
 struct RegexNode
 {
-  struct Regex *regex; /**< Regex containing a regular expression */
-  STAILQ_ENTRY(RegexNode) entries; /**< Next item in list */
+  struct Regex *regex;             ///< Regex containing a regular expression
+  STAILQ_ENTRY(RegexNode) entries; ///< Linked list
 };
 STAILQ_HEAD(RegexList, RegexNode);
 
@@ -76,10 +76,10 @@ STAILQ_HEAD(RegexList, RegexNode);
  */
 struct Replace
 {
-  struct Regex *regex;      /**< Regex containing a regular expression */
-  size_t nmatch;            /**< Match the 'nth' occurrence (0 means the whole expression) */
-  char *templ;              /**< Template to match */
-  STAILQ_ENTRY(Replace) entries; /**< Next item in list */
+  struct Regex *regex;           ///< Regex containing a regular expression
+  size_t nmatch;                 ///< Match the 'nth' occurrence (0 means the whole expression)
+  char *templ;                   ///< Template to match
+  STAILQ_ENTRY(Replace) entries; ///< Linked list
 };
 STAILQ_HEAD(ReplaceList, Replace);
 

diff --git a/mutt_curses.h b/mutt_curses.h
index 494917d5175934317d60ae3b38b8f42b3c39aaeb..81ecdf8a6094748f007ac0215e334145b7d51942 100644 (file)
--- a/mutt_curses.h
+++ b/mutt_curses.h
@@ -179,18 +179,17 @@ enum ColorId
  */
 struct ColorLine
 {
-  regex_t regex;
-  int match; /**< which substringmap 0 for old behaviour */
-  char *pattern;
-  struct PatternList *color_pattern; /**< compiled pattern to speed up index color
-                                          calculation */
-  uint32_t fg;
-  uint32_t bg;
-  int pair;
-
-  bool stop_matching : 1; ///< used by the pager for body patterns, to prevent the color from being retried once it fails
-
-  STAILQ_ENTRY(ColorLine) entries;
+  regex_t regex;                     ///< Compiled regex
+  int match;                         ///< Substring to match, 0 for old behaviour
+  char *pattern;                     ///< Pattern to match
+  struct PatternList *color_pattern; ///< compiled pattern to speed up index color calculation
+  uint32_t fg;                       ///< Foreground colour
+  uint32_t bg;                       ///< Background colour
+  int pair;                          ///< Colour pair index
+
+  bool stop_matching : 1;            ///< used by the pager for body patterns, to prevent the color from being retried once it fails
+
+  STAILQ_ENTRY(ColorLine) entries;   ///< Linked list
 };
 STAILQ_HEAD(ColorLineList, ColorLine);
 

diff --git a/myvar.h b/myvar.h
index 4f274516e4274fa74e78f55faa8f0129594f3026..80eb2c84b970973dcc2b386c106ac4bde8e194a6 100644 (file)
--- a/myvar.h
+++ b/myvar.h
@@ -30,9 +30,9 @@
  */
 struct MyVar
 {
-  char *name;
-  char *value;
-  TAILQ_ENTRY(MyVar) entries;
+  char *name;                 ///< Name of user variable
+  char *value;                ///< Value of user variable
+  TAILQ_ENTRY(MyVar) entries; ///< Linked list
 };
 TAILQ_HEAD(MyVarList, MyVar);
 

diff --git a/ncrypt/crypt_mod.c b/ncrypt/crypt_mod.c
index b3bd1599946d973d4ec7c2baa7a040c400cb1ee9..ed4c1ca5f80657b73bc0785a812ec7ba41e93db2 100644 (file)
--- a/ncrypt/crypt_mod.c
+++ b/ncrypt/crypt_mod.c
@@ -37,8 +37,8 @@
  */
 struct CryptModule
 {
-  struct CryptModuleSpecs *specs;
-  STAILQ_ENTRY(CryptModule) entries;
+  struct CryptModuleSpecs *specs;    ///< Crypto module definition
+  STAILQ_ENTRY(CryptModule) entries; ///< Linked list
 };
 STAILQ_HEAD(CryptModuleList, CryptModule);
 

diff --git a/pattern.c b/pattern.c
index 25857b4727dfa10033ec67e2187ffb14b5cd0629..2d8be07e9b4b542b0c266fe255380a70da77cb8d 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -174,9 +174,9 @@ typedef bool pattern_eat_t(struct Pattern *pat, int flags, struct Buffer *s,
  */
 struct PatternFlags
 {
-  int tag;                ///< character used to represent this op
-  int op;                 ///< operation to perform
-  int flags;              ///< Pattern flags, e.g. #MUTT_PC_FULL_MSG
+  int tag;   ///< Character used to represent this operation, e.g. 'A' for '~A'
+  int op;    ///< Operation to perform, e.g. #MUTT_PAT_SCORE
+  int flags; ///< Pattern flags, e.g. #MUTT_PC_FULL_MSG
   pattern_eat_t *eat_arg; ///< Callback function to parse the argument
 };
 
@@ -1236,57 +1236,57 @@ static bool msg_search(struct Mailbox *m, struct Pattern *pat, int msgno)
  * Flags - Lookup table for all patterns
  */
 static const struct PatternFlags Flags[] = {
-  { 'A', MUTT_ALL,                 0,             NULL },
-  { 'b', MUTT_PAT_BODY,            MUTT_PC_FULL_MSG, eat_regex },
-  { 'B', MUTT_PAT_WHOLE_MSG,       MUTT_PC_FULL_MSG, eat_regex },
-  { 'c', MUTT_PAT_CC,              0,             eat_regex },
-  { 'C', MUTT_PAT_RECIPIENT,       0,             eat_regex },
-  { 'd', MUTT_PAT_DATE,            0,             eat_date },
-  { 'D', MUTT_DELETED,             0,             NULL },
-  { 'e', MUTT_PAT_SENDER,          0,             eat_regex },
-  { 'E', MUTT_EXPIRED,             0,             NULL },
-  { 'f', MUTT_PAT_FROM,            0,             eat_regex },
-  { 'F', MUTT_FLAG,                0,             NULL },
-  { 'g', MUTT_PAT_CRYPT_SIGN,      0,             NULL },
-  { 'G', MUTT_PAT_CRYPT_ENCRYPT,   0,             NULL },
-  { 'h', MUTT_PAT_HEADER,          MUTT_PC_FULL_MSG, eat_regex },
-  { 'H', MUTT_PAT_HORMEL,          0,             eat_regex },
-  { 'i', MUTT_PAT_ID,              0,             eat_regex },
-  { 'I', MUTT_PAT_ID_EXTERNAL,     0,             eat_query },
-  { 'k', MUTT_PAT_PGP_KEY,         0,             NULL },
-  { 'l', MUTT_PAT_LIST,            0,             NULL },
-  { 'L', MUTT_PAT_ADDRESS,         0,             eat_regex },
-  { 'm', MUTT_PAT_MESSAGE,         0,             eat_message_range },
-  { 'M', MUTT_PAT_MIMETYPE,        MUTT_PC_FULL_MSG, eat_regex },
-  { 'n', MUTT_PAT_SCORE,           0,             eat_range },
-  { 'N', MUTT_NEW,                 0,             NULL },
-  { 'O', MUTT_OLD,                 0,             NULL },
-  { 'p', MUTT_PAT_PERSONAL_RECIP,  0,             NULL },
-  { 'P', MUTT_PAT_PERSONAL_FROM,   0,             NULL },
-  { 'Q', MUTT_REPLIED,             0,             NULL },
-  { 'r', MUTT_PAT_DATE_RECEIVED,   0,             eat_date },
-  { 'R', MUTT_READ,                0,             NULL },
-  { 's', MUTT_PAT_SUBJECT,         0,             eat_regex },
-  { 'S', MUTT_SUPERSEDED,          0,             NULL },
-  { 't', MUTT_PAT_TO,              0,             eat_regex },
-  { 'T', MUTT_TAG,                 0,             NULL },
-  { 'u', MUTT_PAT_SUBSCRIBED_LIST, 0,             NULL },
-  { 'U', MUTT_UNREAD,              0,             NULL },
-  { 'v', MUTT_PAT_COLLAPSED,       0,             NULL },
-  { 'V', MUTT_PAT_CRYPT_VERIFIED,  0,             NULL },
+  { 'A', MUTT_ALL,                 0,                NULL              },
+  { 'b', MUTT_PAT_BODY,            MUTT_PC_FULL_MSG, eat_regex         },
+  { 'B', MUTT_PAT_WHOLE_MSG,       MUTT_PC_FULL_MSG, eat_regex         },
+  { 'c', MUTT_PAT_CC,              0,                eat_regex         },
+  { 'C', MUTT_PAT_RECIPIENT,       0,                eat_regex         },
+  { 'd', MUTT_PAT_DATE,            0,                eat_date          },
+  { 'D', MUTT_DELETED,             0,                NULL              },
+  { 'e', MUTT_PAT_SENDER,          0,                eat_regex         },
+  { 'E', MUTT_EXPIRED,             0,                NULL              },
+  { 'f', MUTT_PAT_FROM,            0,                eat_regex         },
+  { 'F', MUTT_FLAG,                0,                NULL              },
+  { 'g', MUTT_PAT_CRYPT_SIGN,      0,                NULL              },
+  { 'G', MUTT_PAT_CRYPT_ENCRYPT,   0,                NULL              },
+  { 'h', MUTT_PAT_HEADER,          MUTT_PC_FULL_MSG, eat_regex         },
+  { 'H', MUTT_PAT_HORMEL,          0,                eat_regex         },
+  { 'i', MUTT_PAT_ID,              0,                eat_regex         },
+  { 'I', MUTT_PAT_ID_EXTERNAL,     0,                eat_query         },
+  { 'k', MUTT_PAT_PGP_KEY,         0,                NULL              },
+  { 'l', MUTT_PAT_LIST,            0,                NULL              },
+  { 'L', MUTT_PAT_ADDRESS,         0,                eat_regex         },
+  { 'm', MUTT_PAT_MESSAGE,         0,                eat_message_range },
+  { 'M', MUTT_PAT_MIMETYPE,        MUTT_PC_FULL_MSG, eat_regex         },
+  { 'n', MUTT_PAT_SCORE,           0,                eat_range         },
+  { 'N', MUTT_NEW,                 0,                NULL              },
+  { 'O', MUTT_OLD,                 0,                NULL              },
+  { 'p', MUTT_PAT_PERSONAL_RECIP,  0,                NULL              },
+  { 'P', MUTT_PAT_PERSONAL_FROM,   0,                NULL              },
+  { 'Q', MUTT_REPLIED,             0,                NULL              },
+  { 'r', MUTT_PAT_DATE_RECEIVED,   0,                eat_date          },
+  { 'R', MUTT_READ,                0,                NULL              },
+  { 's', MUTT_PAT_SUBJECT,         0,                eat_regex         },
+  { 'S', MUTT_SUPERSEDED,          0,                NULL              },
+  { 't', MUTT_PAT_TO,              0,                eat_regex         },
+  { 'T', MUTT_TAG,                 0,                NULL              },
+  { 'u', MUTT_PAT_SUBSCRIBED_LIST, 0,                NULL              },
+  { 'U', MUTT_UNREAD,              0,                NULL              },
+  { 'v', MUTT_PAT_COLLAPSED,       0,                NULL              },
+  { 'V', MUTT_PAT_CRYPT_VERIFIED,  0,                NULL              },
 #ifdef USE_NNTP
-  { 'w', MUTT_PAT_NEWSGROUPS,      0,             eat_regex },
+  { 'w', MUTT_PAT_NEWSGROUPS,      0,                eat_regex         },
 #endif
-  { 'x', MUTT_PAT_REFERENCE,       0,             eat_regex },
-  { 'X', MUTT_PAT_MIMEATTACH,      0,             eat_range },
-  { 'y', MUTT_PAT_XLABEL,          0,             eat_regex },
-  { 'Y', MUTT_PAT_DRIVER_TAGS,     0,             eat_regex },
-  { 'z', MUTT_PAT_SIZE,            0,             eat_range },
-  { '=', MUTT_PAT_DUPLICATED,      0,             NULL },
-  { '$', MUTT_PAT_UNREFERENCED,    0,             NULL },
-  { '#', MUTT_PAT_BROKEN,          0,             NULL },
-  { '/', MUTT_PAT_SERVERSEARCH,    0,             eat_regex },
-  { 0,   0,                        0,             NULL },
+  { 'x', MUTT_PAT_REFERENCE,       0,                eat_regex         },
+  { 'X', MUTT_PAT_MIMEATTACH,      0,                eat_range         },
+  { 'y', MUTT_PAT_XLABEL,          0,                eat_regex         },
+  { 'Y', MUTT_PAT_DRIVER_TAGS,     0,                eat_regex         },
+  { 'z', MUTT_PAT_SIZE,            0,                eat_range         },
+  { '=', MUTT_PAT_DUPLICATED,      0,                NULL              },
+  { '$', MUTT_PAT_UNREFERENCED,    0,                NULL              },
+  { '#', MUTT_PAT_BROKEN,          0,                NULL              },
+  { '/', MUTT_PAT_SERVERSEARCH,    0,                eat_regex         },
+  { 0,   0,                        0,                NULL              },
 };
 // clang-format on
 

diff --git a/pattern.h b/pattern.h
index 7babdd4c246ebab6874744f5e9cb9452aaa6b7f2..59e9357c2997f3b5803393249c4dad207a0bc486 100644 (file)
--- a/pattern.h
+++ b/pattern.h
@@ -48,25 +48,25 @@ typedef uint8_t PatternCompFlags;       ///< Flags for mutt_pattern_comp(), e.g.
  */
 struct Pattern
 {
-  short op;
-  bool pat_not : 1;
-  bool alladdr : 1;
-  bool stringmatch : 1;
-  bool groupmatch : 1;
-  bool ign_case : 1; /**< ignore case for local stringmatch searches */
-  bool isalias : 1;
-  bool dynamic : 1;  ///< evaluate date ranges at run time
-  bool ismulti : 1; /**< multiple case (only for I pattern now) */
-  int min;
-  int max;
-  struct PatternList *child; /**< arguments to logical op */
+  short op;                      ///< Operation, e.g. MUTT_PAT_SCORE
+  bool pat_not     : 1;          ///< Pattern should be inverted (not)
+  bool alladdr     : 1;          ///< All Addresses in the list must match
+  bool stringmatch : 1;          ///< Check a string for a match
+  bool groupmatch  : 1;          ///< Check a group of Addresses
+  bool ign_case    : 1;          ///< Ignore case for local stringmatch searches
+  bool isalias     : 1;          ///< Is there an alias for this Address?
+  bool dynamic     : 1;          ///< Evaluate date ranges at run time
+  bool ismulti     : 1;          ///< Multiple case (only for ~I pattern now)
+  int min;                       ///< Minimum for range checks
+  int max;                       ///< Maximum for range checks
+  struct PatternList *child;     ///< Arguments to logical operation
   union {
-    regex_t *regex;
-    struct Group *group;
-    char *str;
-    struct ListHead multi_cases;
+    regex_t *regex;              ///< Compiled regex, for non-pattern matching
+    struct Group *group;         ///< Address group if groupmatch is set
+    char *str;                   ///< String, if stringmatch is set
+    struct ListHead multi_cases; ///< Multiple strings for ~I pattern
   } p;
-  SLIST_ENTRY(Pattern) entries;
+  SLIST_ENTRY(Pattern) entries;  ///< Linked list
 };
 SLIST_HEAD(PatternList, Pattern);