Switch to Linux kernel coding style

Convert our code base to adhere to Linux kernel coding style using
Lindent, with the following exceptions:

* Use spaces, instead of tabs, for indentation.
* Use 2-character indentations (instead of 8 characters).

Rationale: We currently have too much levels of indentation. Using
8-character tabs would make huge code parts unreadable. These need to be
cleaned up before we can switch to 8 characters.

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>

1 files changed, 549 insertions, 664 deletions

diff --git a/src/recur.c b/src/recur.c
index d1a5516..dad9c25 100644
--- a/src/recur.c
+++ b/src/recur.c
@@ -42,242 +42,217 @@
 
 #include "calcurse.h"
 
-llist_ts_t                 recur_alist_p;
-llist_t                    recur_elist;
-static struct recur_event  bkp_cut_recur_event;
+llist_ts_t recur_alist_p;
+llist_t recur_elist;
+static struct recur_event bkp_cut_recur_event;
 static struct recur_apoint bkp_cut_recur_apoint;
 
-static void
-free_exc (struct excp *exc)
+static void free_exc(struct excp *exc)
 {
-  mem_free (exc);
+  mem_free(exc);
 }
 
-static void
-free_exc_list (llist_t *exc)
+static void free_exc_list(llist_t * exc)
 {
-  LLIST_FREE_INNER (exc, free_exc);
-  LLIST_FREE (exc);
+  LLIST_FREE_INNER(exc, free_exc);
+  LLIST_FREE(exc);
 }
 
-static int
-exc_cmp_day (struct excp *a, struct excp *b)
+static int exc_cmp_day(struct excp *a, struct excp *b)
 {
   return a->st < b->st ? -1 : (a->st == b->st ? 0 : 1);
 }
 
-static void
-recur_add_exc (llist_t *exc, long day)
+static void recur_add_exc(llist_t * exc, long day)
 {
-  struct excp *o = mem_malloc (sizeof (struct excp));
+  struct excp *o = mem_malloc(sizeof(struct excp));
   o->st = day;
 
-  LLIST_ADD_SORTED (exc, o, exc_cmp_day);
+  LLIST_ADD_SORTED(exc, o, exc_cmp_day);
 }
 
-static void
-exc_dup (llist_t *in, llist_t *exc)
+static void exc_dup(llist_t * in, llist_t * exc)
 {
   llist_item_t *i;
 
-  LLIST_INIT (in);
+  LLIST_INIT(in);
 
-  if (exc)
-    {
-      LLIST_FOREACH (exc, i)
-        {
-          struct excp *p = LLIST_GET_DATA (i);
-          recur_add_exc (in, p->st);
-        }
+  if (exc) {
+    LLIST_FOREACH(exc, i) {
+      struct excp *p = LLIST_GET_DATA(i);
+      recur_add_exc(in, p->st);
     }
+  }
 }
 
-void
-recur_event_free_bkp (void)
+void recur_event_free_bkp(void)
 {
-  if (bkp_cut_recur_event.mesg)
-    {
-      mem_free (bkp_cut_recur_event.mesg);
-      bkp_cut_recur_event.mesg = 0;
-    }
-  if (bkp_cut_recur_event.rpt)
-    {
-      mem_free (bkp_cut_recur_event.rpt);
-      bkp_cut_recur_event.rpt = 0;
-    }
-  free_exc_list (&bkp_cut_recur_event.exc);
-  erase_note (&bkp_cut_recur_event.note);
+  if (bkp_cut_recur_event.mesg) {
+    mem_free(bkp_cut_recur_event.mesg);
+    bkp_cut_recur_event.mesg = 0;
+  }
+  if (bkp_cut_recur_event.rpt) {
+    mem_free(bkp_cut_recur_event.rpt);
+    bkp_cut_recur_event.rpt = 0;
+  }
+  free_exc_list(&bkp_cut_recur_event.exc);
+  erase_note(&bkp_cut_recur_event.note);
 }
 
-void
-recur_apoint_free_bkp (void)
+void recur_apoint_free_bkp(void)
 {
-  if (bkp_cut_recur_apoint.mesg)
-    {
-      mem_free (bkp_cut_recur_apoint.mesg);
-      bkp_cut_recur_apoint.mesg = 0;
-    }
-  if (bkp_cut_recur_apoint.rpt)
-    {
-      mem_free (bkp_cut_recur_apoint.rpt);
-      bkp_cut_recur_apoint.rpt = 0;
-    }
-  free_exc_list (&bkp_cut_recur_apoint.exc);
-  erase_note (&bkp_cut_recur_apoint.note);
+  if (bkp_cut_recur_apoint.mesg) {
+    mem_free(bkp_cut_recur_apoint.mesg);
+    bkp_cut_recur_apoint.mesg = 0;
+  }
+  if (bkp_cut_recur_apoint.rpt) {
+    mem_free(bkp_cut_recur_apoint.rpt);
+    bkp_cut_recur_apoint.rpt = 0;
+  }
+  free_exc_list(&bkp_cut_recur_apoint.exc);
+  erase_note(&bkp_cut_recur_apoint.note);
 }
 
-static void
-recur_event_dup (struct recur_event *in, struct recur_event *bkp)
+static void recur_event_dup(struct recur_event *in, struct recur_event *bkp)
 {
-  EXIT_IF (!in || !bkp, _("null pointer"));
+  EXIT_IF(!in || !bkp, _("null pointer"));
 
   bkp->id = in->id;
   bkp->day = in->day;
-  bkp->mesg = mem_strdup (in->mesg);
+  bkp->mesg = mem_strdup(in->mesg);
 
-  bkp->rpt = mem_malloc (sizeof (struct rpt));
+  bkp->rpt = mem_malloc(sizeof(struct rpt));
   bkp->rpt->type = in->rpt->type;
   bkp->rpt->freq = in->rpt->freq;
   bkp->rpt->until = in->rpt->until;
 
-  exc_dup (&bkp->exc, &in->exc);
+  exc_dup(&bkp->exc, &in->exc);
 
   if (in->note)
-    bkp->note = mem_strdup (in->note);
+    bkp->note = mem_strdup(in->note);
 }
 
-static void
-recur_apoint_dup (struct recur_apoint *in, struct recur_apoint *bkp)
+static void recur_apoint_dup(struct recur_apoint *in, struct recur_apoint *bkp)
 {
-  EXIT_IF (!in || !bkp, _("null pointer"));
+  EXIT_IF(!in || !bkp, _("null pointer"));
 
   bkp->start = in->start;
   bkp->dur = in->dur;
   bkp->state = in->state;
-  bkp->mesg = mem_strdup (in->mesg);
+  bkp->mesg = mem_strdup(in->mesg);
 
-  bkp->rpt = mem_malloc (sizeof (struct rpt));
+  bkp->rpt = mem_malloc(sizeof(struct rpt));
   bkp->rpt->type = in->rpt->type;
   bkp->rpt->freq = in->rpt->freq;
   bkp->rpt->until = in->rpt->until;
 
-  exc_dup (&bkp->exc, &in->exc);
+  exc_dup(&bkp->exc, &in->exc);
 
   if (in->note)
-    bkp->note = mem_strdup (in->note);
+    bkp->note = mem_strdup(in->note);
 }
 
-void
-recur_apoint_llist_init (void)
+void recur_apoint_llist_init(void)
 {
-  LLIST_TS_INIT (&recur_alist_p);
+  LLIST_TS_INIT(&recur_alist_p);
 }
 
-static void
-recur_apoint_free (struct recur_apoint *rapt)
+static void recur_apoint_free(struct recur_apoint *rapt)
 {
-  mem_free (rapt->mesg);
+  mem_free(rapt->mesg);
   if (rapt->note)
-    mem_free (rapt->note);
+    mem_free(rapt->note);
   if (rapt->rpt)
-    mem_free (rapt->rpt);
-  free_exc_list (&rapt->exc);
-  mem_free (rapt);
+    mem_free(rapt->rpt);
+  free_exc_list(&rapt->exc);
+  mem_free(rapt);
 }
 
-static void
-recur_event_free (struct recur_event *rev)
+static void recur_event_free(struct recur_event *rev)
 {
-  mem_free (rev->mesg);
+  mem_free(rev->mesg);
   if (rev->note)
-    mem_free (rev->note);
+    mem_free(rev->note);
   if (rev->rpt)
-    mem_free (rev->rpt);
-  free_exc_list (&rev->exc);
-  mem_free (rev);
+    mem_free(rev->rpt);
+  free_exc_list(&rev->exc);
+  mem_free(rev);
 }
 
-void
-recur_apoint_llist_free (void)
+void recur_apoint_llist_free(void)
 {
-  LLIST_TS_FREE_INNER (&recur_alist_p, recur_apoint_free);
-  LLIST_TS_FREE (&recur_alist_p);
+  LLIST_TS_FREE_INNER(&recur_alist_p, recur_apoint_free);
+  LLIST_TS_FREE(&recur_alist_p);
 }
 
-void
-recur_event_llist_free (void)
+void recur_event_llist_free(void)
 {
-  LLIST_FREE_INNER (&recur_elist, recur_event_free);
-  LLIST_FREE (&recur_elist);
+  LLIST_FREE_INNER(&recur_elist, recur_event_free);
+  LLIST_FREE(&recur_elist);
 }
 
 static int
-recur_apoint_cmp_start (struct recur_apoint *a, struct recur_apoint *b)
+recur_apoint_cmp_start(struct recur_apoint *a, struct recur_apoint *b)
 {
   return a->start < b->start ? -1 : (a->start == b->start ? 0 : 1);
 }
 
-static int
-recur_event_cmp_day (struct recur_event *a, struct recur_event *b)
+static int recur_event_cmp_day(struct recur_event *a, struct recur_event *b)
 {
   return a->day < b->day ? -1 : (a->day == b->day ? 0 : 1);
 }
 
 /* Insert a new recursive appointment in the general linked list */
-struct recur_apoint *
-recur_apoint_new (char *mesg, char *note, long start, long dur, char state,
-                  int type, int freq, long until, llist_t *except)
+struct recur_apoint *recur_apoint_new(char *mesg, char *note, long start,
+                                      long dur, char state, int type, int freq,
+                                      long until, llist_t * except)
 {
-  struct recur_apoint *rapt = mem_malloc (sizeof (struct recur_apoint));
+  struct recur_apoint *rapt = mem_malloc(sizeof(struct recur_apoint));
 
-  rapt->rpt = mem_malloc (sizeof (struct rpt));
-  rapt->mesg = mem_strdup (mesg);
-  rapt->note = (note != NULL) ? mem_strdup (note) : 0;
+  rapt->rpt = mem_malloc(sizeof(struct rpt));
+  rapt->mesg = mem_strdup(mesg);
+  rapt->note = (note != NULL) ? mem_strdup(note) : 0;
   rapt->start = start;
   rapt->state = state;
   rapt->dur = dur;
   rapt->rpt->type = type;
   rapt->rpt->freq = freq;
   rapt->rpt->until = until;
-  if (except)
-    {
-      exc_dup (&rapt->exc, except);
-      free_exc_list (except);
-    }
-  else
-    LLIST_INIT (&rapt->exc);
+  if (except) {
+    exc_dup(&rapt->exc, except);
+    free_exc_list(except);
+  } else
+    LLIST_INIT(&rapt->exc);
 
-  LLIST_TS_LOCK (&recur_alist_p);
-  LLIST_TS_ADD_SORTED (&recur_alist_p, rapt, recur_apoint_cmp_start);
-  LLIST_TS_UNLOCK (&recur_alist_p);
+  LLIST_TS_LOCK(&recur_alist_p);
+  LLIST_TS_ADD_SORTED(&recur_alist_p, rapt, recur_apoint_cmp_start);
+  LLIST_TS_UNLOCK(&recur_alist_p);
 
   return rapt;
 }
 
 /* Insert a new recursive event in the general linked list */
-struct recur_event *
-recur_event_new (char *mesg, char *note, long day, int id, int type, int freq,
-                 long until, llist_t *except)
+struct recur_event *recur_event_new(char *mesg, char *note, long day, int id,
+                                    int type, int freq, long until,
+                                    llist_t * except)
 {
-  struct recur_event *rev = mem_malloc (sizeof (struct recur_event));
+  struct recur_event *rev = mem_malloc(sizeof(struct recur_event));
 
-  rev->rpt = mem_malloc (sizeof (struct rpt));
-  rev->mesg = mem_strdup (mesg);
-  rev->note = (note != NULL) ? mem_strdup (note) : 0;
+  rev->rpt = mem_malloc(sizeof(struct rpt));
+  rev->mesg = mem_strdup(mesg);
+  rev->note = (note != NULL) ? mem_strdup(note) : 0;
   rev->day = day;
   rev->id = id;
   rev->rpt->type = type;
   rev->rpt->freq = freq;
   rev->rpt->until = until;
-  if (except)
-    {
-      exc_dup (&rev->exc, except);
-      free_exc_list (except);
-    }
-  else
-    LLIST_INIT (&rev->exc);
+  if (except) {
+    exc_dup(&rev->exc, except);
+    free_exc_list(except);
+  } else
+    LLIST_INIT(&rev->exc);
 
-  LLIST_ADD_SORTED (&recur_elist, rev, recur_event_cmp_day);
+  LLIST_ADD_SORTED(&recur_elist, rev, recur_event_cmp_day);
 
   return rev;
 }
@@ -286,29 +261,27 @@ recur_event_new (char *mesg, char *note, long day, int id, int type, int freq,
  * Correspondance between the defines on recursive type,
  * and the letter to be written in file.
  */
-char
-recur_def2char (enum recur_type define)
+char recur_def2char(enum recur_type define)
 {
   char recur_char;
 
-  switch (define)
-    {
-    case RECUR_DAILY:
-      recur_char = 'D';
-      break;
-    case RECUR_WEEKLY:
-      recur_char = 'W';
-      break;
-    case RECUR_MONTHLY:
-      recur_char = 'M';
-      break;
-    case RECUR_YEARLY:
-      recur_char = 'Y';
-      break;
-    default:
-      EXIT (_("unknown repetition type"));
-      return 0;
-    }
+  switch (define) {
+  case RECUR_DAILY:
+    recur_char = 'D';
+    break;
+  case RECUR_WEEKLY:
+    recur_char = 'W';
+    break;
+  case RECUR_MONTHLY:
+    recur_char = 'M';
+    break;
+  case RECUR_YEARLY:
+    recur_char = 'Y';
+    break;
+  default:
+    EXIT(_("unknown repetition type"));
+    return 0;
+  }
 
   return recur_char;
 }
@@ -317,185 +290,166 @@ recur_def2char (enum recur_type define)
  * Correspondance between the letters written in file and the defines
  * concerning the recursive type.
  */
-int
-recur_char2def (char type)
+int recur_char2def(char type)
 {
   int recur_def;
 
-  switch (type)
-    {
-    case 'D':
-      recur_def = RECUR_DAILY;
-      break;
-    case 'W':
-      recur_def = RECUR_WEEKLY;
-      break;
-    case 'M':
-      recur_def = RECUR_MONTHLY;
-      break;
-    case 'Y':
-      recur_def = RECUR_YEARLY;
-      break;
-    default:
-      EXIT (_("unknown character"));
-      return 0;
-    }
+  switch (type) {
+  case 'D':
+    recur_def = RECUR_DAILY;
+    break;
+  case 'W':
+    recur_def = RECUR_WEEKLY;
+    break;
+  case 'M':
+    recur_def = RECUR_MONTHLY;
+    break;
+  case 'Y':
+    recur_def = RECUR_YEARLY;
+    break;
+  default:
+    EXIT(_("unknown character"));
+    return 0;
+  }
   return recur_def;
 }
 
 /* Write days for which recurrent items should not be repeated. */
-static void
-recur_write_exc (llist_t *lexc, FILE *f)
+static void recur_write_exc(llist_t * lexc, FILE * f)
 {
   llist_item_t *i;
   struct tm *lt;
   time_t t;
   int st_mon, st_day, st_year;
 
-  LLIST_FOREACH (lexc, i)
-    {
-      struct excp *exc = LLIST_GET_DATA (i);
-      t = exc->st;
-      lt = localtime (&t);
-      st_mon = lt->tm_mon + 1;
-      st_day = lt->tm_mday;
-      st_year = lt->tm_year + 1900;
-      fprintf (f, " !%02u/%02u/%04u", st_mon, st_day, st_year);
-    }
+  LLIST_FOREACH(lexc, i) {
+    struct excp *exc = LLIST_GET_DATA(i);
+    t = exc->st;
+    lt = localtime(&t);
+    st_mon = lt->tm_mon + 1;
+    st_day = lt->tm_mday;
+    st_year = lt->tm_year + 1900;
+    fprintf(f, " !%02u/%02u/%04u", st_mon, st_day, st_year);
+  }
 }
 
 /* Load the recursive appointment description */
-struct recur_apoint *
-recur_apoint_scan (FILE *f, struct tm start, struct tm end, char type,
-                   int freq, struct tm until, char *note, llist_t *exc,
-                   char state)
+struct recur_apoint *recur_apoint_scan(FILE * f, struct tm start, struct tm end,
+                                       char type, int freq, struct tm until,
+                                       char *note, llist_t * exc, char state)
 {
   char buf[BUFSIZ], *nl;
   time_t tstart, tend, tuntil;
 
   /* Read the appointment description */
-  if (!fgets (buf, sizeof buf, f))
+  if (!fgets(buf, sizeof buf, f))
     return NULL;
 
-  nl = strchr (buf, '\n');
-  if (nl)
-    {
-      *nl = '\0';
-    }
+  nl = strchr(buf, '\n');
+  if (nl) {
+    *nl = '\0';
+  }
   start.tm_sec = end.tm_sec = 0;
   start.tm_isdst = end.tm_isdst = -1;
   start.tm_year -= 1900;
   start.tm_mon--;
   end.tm_year -= 1900;
   end.tm_mon--;
-  tstart = mktime (&start);
-  tend = mktime (&end);
-
-  if (until.tm_year != 0)
-    {
-      until.tm_hour = 23;
-      until.tm_min = 59;
-      until.tm_sec = 0;
-      until.tm_isdst = -1;
-      until.tm_year -= 1900;
-      until.tm_mon--;
-      tuntil = mktime (&until);
-    }
-  else
-    {
-      tuntil = 0;
-    }
-  EXIT_IF (tstart == -1 || tend == -1 || tstart > tend || tuntil == -1,
-           _("date error in appointment"));
-
-  return recur_apoint_new (buf, note, tstart, tend - tstart, state,
-                           recur_char2def(type), freq, tuntil, exc);
+  tstart = mktime(&start);
+  tend = mktime(&end);
+
+  if (until.tm_year != 0) {
+    until.tm_hour = 23;
+    until.tm_min = 59;
+    until.tm_sec = 0;
+    until.tm_isdst = -1;
+    until.tm_year -= 1900;
+    until.tm_mon--;
+    tuntil = mktime(&until);
+  } else {
+    tuntil = 0;
+  }
+  EXIT_IF(tstart == -1 || tend == -1 || tstart > tend || tuntil == -1,
+          _("date error in appointment"));
+
+  return recur_apoint_new(buf, note, tstart, tend - tstart, state,
+                          recur_char2def(type), freq, tuntil, exc);
 }
 
 /* Load the recursive events from file */
-struct recur_event *
-recur_event_scan (FILE *f, struct tm start, int id, char type, int freq,
-                  struct tm until, char *note, llist_t *exc)
+struct recur_event *recur_event_scan(FILE * f, struct tm start, int id,
+                                     char type, int freq, struct tm until,
+                                     char *note, llist_t * exc)
 {
   char buf[BUFSIZ], *nl;
   time_t tstart, tuntil;
 
   /* Read the event description */
-  if (!fgets (buf, sizeof buf, f))
+  if (!fgets(buf, sizeof buf, f))
     return NULL;
 
-  nl = strchr (buf, '\n');
-  if (nl)
-    {
-      *nl = '\0';
-    }
+  nl = strchr(buf, '\n');
+  if (nl) {
+    *nl = '\0';
+  }
   start.tm_hour = until.tm_hour = 0;
   start.tm_min = until.tm_min = 0;
   start.tm_sec = until.tm_sec = 0;
   start.tm_isdst = until.tm_isdst = -1;
   start.tm_year -= 1900;
   start.tm_mon--;
-  if (until.tm_year != 0)
-    {
-      until.tm_year -= 1900;
-      until.tm_mon--;
-      tuntil = mktime (&until);
-    }
-  else
-    {
-      tuntil = 0;
-    }
-  tstart = mktime (&start);
-  EXIT_IF (tstart == -1 || tuntil == -1,
-           _("date error in event"));
-
-  return recur_event_new (buf, note, tstart, id, recur_char2def(type), freq,
-                          tuntil, exc);
+  if (until.tm_year != 0) {
+    until.tm_year -= 1900;
+    until.tm_mon--;
+    tuntil = mktime(&until);
+  } else {
+    tuntil = 0;
+  }
+  tstart = mktime(&start);
+  EXIT_IF(tstart == -1 || tuntil == -1, _("date error in event"));
+
+  return recur_event_new(buf, note, tstart, id, recur_char2def(type), freq,
+                         tuntil, exc);
 }
 
 /* Writting of a recursive appointment into file. */
-void
-recur_apoint_write (struct recur_apoint *o, FILE *f)
+void recur_apoint_write(struct recur_apoint *o, FILE * f)
 {
   struct tm *lt;
   time_t t;
 
   t = o->start;
-  lt = localtime (&t);
-  fprintf (f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
-           1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
+  lt = localtime(&t);
+  fprintf(f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
+          1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
 
   t = o->start + o->dur;
-  lt = localtime (&t);
-  fprintf (f, " -> %02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
-           1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
+  lt = localtime(&t);
+  fprintf(f, " -> %02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
+          1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
 
   t = o->rpt->until;
-  if (t == 0)
-    {				/* We have an endless recurrent appointment. */
-      fprintf (f, " {%d%c", o->rpt->freq, recur_def2char (o->rpt->type));
-    }
-  else
-    {
-      lt = localtime (&t);
-      fprintf (f, " {%d%c -> %02u/%02u/%04u", o->rpt->freq,
-               recur_def2char (o->rpt->type), lt->tm_mon + 1, lt->tm_mday,
-               1900 + lt->tm_year);
-    }
-  recur_write_exc (&o->exc, f);
-  fputs ("} ", f);
+  if (t == 0) {                 /* We have an endless recurrent appointment. */
+    fprintf(f, " {%d%c", o->rpt->freq, recur_def2char(o->rpt->type));
+  } else {
+    lt = localtime(&t);
+    fprintf(f, " {%d%c -> %02u/%02u/%04u", o->rpt->freq,
+            recur_def2char(o->rpt->type), lt->tm_mon + 1, lt->tm_mday,
+            1900 + lt->tm_year);
+  }
+  recur_write_exc(&o->exc, f);
+  fputs("} ", f);
   if (o->note != NULL)
-    fprintf (f, ">%s ", o->note);
+    fprintf(f, ">%s ", o->note);
   if (o->state & APOINT_NOTIFY)
-    fputc ('!', f);
+    fputc('!', f);
   else
-    fputc ('|', f);
-  fprintf (f, "%s\n", o->mesg);
+    fputc('|', f);
+  fprintf(f, "%s\n", o->mesg);
 }
 
 /* Writting of a recursive event into file. */
-void
-recur_event_write (struct recur_event *o, FILE *f)
+void recur_event_write(struct recur_event *o, FILE * f)
 {
   struct tm *lt;
   time_t t;
@@ -503,55 +457,48 @@ recur_event_write (struct recur_event *o, FILE *f)
   int end_mon, end_day, end_year;
 
   t = o->day;
-  lt = localtime (&t);
+  lt = localtime(&t);
   st_mon = lt->tm_mon + 1;
   st_day = lt->tm_mday;
   st_year = lt->tm_year + 1900;
   t = o->rpt->until;
-  if (t == 0)
-    {				/* We have an endless recurrent event. */
-      fprintf (f, "%02u/%02u/%04u [%d] {%d%c", st_mon, st_day, st_year, o->id,
-               o->rpt->freq, recur_def2char (o->rpt->type));
-    }
-  else
-    {
-      lt = localtime (&t);
-      end_mon = lt->tm_mon + 1;
-      end_day = lt->tm_mday;
-      end_year = lt->tm_year + 1900;
-      fprintf (f, "%02u/%02u/%04u [%d] {%d%c -> %02u/%02u/%04u", st_mon,
-               st_day, st_year, o->id, o->rpt->freq,
-               recur_def2char (o->rpt->type), end_mon, end_day, end_year);
-    }
-  recur_write_exc (&o->exc, f);
-  fputs ("} ", f);
+  if (t == 0) {                 /* We have an endless recurrent event. */
+    fprintf(f, "%02u/%02u/%04u [%d] {%d%c", st_mon, st_day, st_year, o->id,
+            o->rpt->freq, recur_def2char(o->rpt->type));
+  } else {
+    lt = localtime(&t);
+    end_mon = lt->tm_mon + 1;
+    end_day = lt->tm_mday;
+    end_year = lt->tm_year + 1900;
+    fprintf(f, "%02u/%02u/%04u [%d] {%d%c -> %02u/%02u/%04u", st_mon,
+            st_day, st_year, o->id, o->rpt->freq,
+            recur_def2char(o->rpt->type), end_mon, end_day, end_year);
+  }
+  recur_write_exc(&o->exc, f);
+  fputs("} ", f);
   if (o->note != NULL)
-    fprintf (f, ">%s ", o->note);
-  fprintf (f, "%s\n", o->mesg);
+    fprintf(f, ">%s ", o->note);
+  fprintf(f, "%s\n", o->mesg);
 }
 
 /* Write recursive items to file. */
-void
-recur_save_data (FILE *f)
+void recur_save_data(FILE * f)
 {
   llist_item_t *i;
 
-  LLIST_FOREACH (&recur_elist, i)
-    {
-      struct recur_event *rev = LLIST_GET_DATA (i);
-      recur_event_write (rev, f);
-    }
-
-  LLIST_TS_LOCK (&recur_alist_p);
-  LLIST_TS_FOREACH (&recur_alist_p, i)
-    {
-      struct recur_apoint *rapt = LLIST_GET_DATA (i);
-      recur_apoint_write (rapt, f);
-    }
-  LLIST_TS_UNLOCK (&recur_alist_p);
+  LLIST_FOREACH(&recur_elist, i) {
+    struct recur_event *rev = LLIST_GET_DATA(i);
+    recur_event_write(rev, f);
+  }
+
+  LLIST_TS_LOCK(&recur_alist_p);
+  LLIST_TS_FOREACH(&recur_alist_p, i) {
+    struct recur_apoint *rapt = LLIST_GET_DATA(i);
+    recur_apoint_write(rapt, f);
+  }
+  LLIST_TS_UNLOCK(&recur_alist_p);
 }
 
-
 /*
  * The two following defines together with the diff_days, diff_months and
  * diff_years functions were provided by Lukas Fleischer to correct the wrong
@@ -564,10 +511,8 @@ recur_save_data (FILE *f)
 #define LEAPCOUNT(start, end)                                           \
   (BC(start, end, 4) - BC(start, end, 100) + BC(start, end, 400))
 
-
 /* Calculate the difference in days between two dates. */
-static long
-diff_days (struct tm lt_start, struct tm lt_end)
+static long diff_days(struct tm lt_start, struct tm lt_end)
 {
   long diff;
 
@@ -576,19 +521,17 @@ diff_days (struct tm lt_start, struct tm lt_end)
 
   diff = lt_end.tm_yday - lt_start.tm_yday;
 
-  if (lt_end.tm_year > lt_start.tm_year)
-    {
-      diff += (lt_end.tm_year - lt_start.tm_year) * YEARINDAYS;
-      diff += LEAPCOUNT (lt_start.tm_year + TM_YEAR_BASE,
-                         lt_end.tm_year + TM_YEAR_BASE - 1);
-    }
+  if (lt_end.tm_year > lt_start.tm_year) {
+    diff += (lt_end.tm_year - lt_start.tm_year) * YEARINDAYS;
+    diff += LEAPCOUNT(lt_start.tm_year + TM_YEAR_BASE,
+                      lt_end.tm_year + TM_YEAR_BASE - 1);
+  }
 
   return diff;
 }
 
 /* Calculate the difference in months between two dates. */
-static long
-diff_months (struct tm lt_start, struct tm lt_end)
+static long diff_months(struct tm lt_start, struct tm lt_end)
 {
   long diff;
 
@@ -602,14 +545,12 @@ diff_months (struct tm lt_start, struct tm lt_end)
 }
 
 /* Calculate the difference in years between two dates. */
-static long
-diff_years (struct tm lt_start, struct tm lt_end)
+static long diff_years(struct tm lt_start, struct tm lt_end)
 {
   return lt_end.tm_year - lt_start.tm_year;
 }
 
-static int
-exc_inday (struct excp *exc, long day_start)
+static int exc_inday(struct excp *exc, long day_start)
 {
   return (exc->st >= day_start && exc->st < day_start + DAYINSEC);
 }
@@ -624,9 +565,9 @@ exc_inday (struct excp *exc, long day_start)
  * calculation of recurrent dates after a turn of years.
  */
 unsigned
-recur_item_find_occurrence (long item_start, long item_dur, llist_t *item_exc,
-                            int rpt_type, int rpt_freq, long rpt_until,
-                            long day_start, unsigned *occurrence)
+recur_item_find_occurrence(long item_start, long item_dur, llist_t * item_exc,
+                           int rpt_type, int rpt_freq, long rpt_until,
+                           long day_start, unsigned *occurrence)
 {
   struct date start_date;
   long diff, span;
@@ -640,81 +581,77 @@ recur_item_find_occurrence (long item_start, long item_dur, llist_t *item_exc,
     return 0;
 
   t = day_start;
-  lt_day = *localtime (&t);
+  lt_day = *localtime(&t);
 
   t = item_start;
-  lt_item = *localtime (&t);
+  lt_item = *localtime(&t);
 
   lt_item_day = lt_item;
   lt_item_day.tm_sec = lt_item_day.tm_min = lt_item_day.tm_hour = 0;
 
-  span = (item_start - mktime (&lt_item_day) + item_dur - 1) / DAYINSEC;
-
-  switch (rpt_type)
-    {
-    case RECUR_DAILY:
-      diff = diff_days (lt_item_day, lt_day) % rpt_freq;
-      lt_item_day.tm_mday = lt_day.tm_mday - diff;
-      lt_item_day.tm_mon = lt_day.tm_mon;
-      lt_item_day.tm_year = lt_day.tm_year;
-      break;
-    case RECUR_WEEKLY:
-      diff = diff_days (lt_item_day, lt_day) % (rpt_freq * WEEKINDAYS);
-      lt_item_day.tm_mday = lt_day.tm_mday - diff;
-      lt_item_day.tm_mon = lt_day.tm_mon;
-      lt_item_day.tm_year = lt_day.tm_year;
-      break;
-    case RECUR_MONTHLY:
-      diff = diff_months (lt_item_day, lt_day) % rpt_freq;
-      if (lt_day.tm_mday < lt_item_day.tm_mday)
-        diff++;
-      lt_item_day.tm_mon = lt_day.tm_mon - diff;
-      lt_item_day.tm_year = lt_day.tm_year;
-      break;
-    case RECUR_YEARLY:
-      diff = diff_years (lt_item_day, lt_day) % rpt_freq;
-      if (lt_day.tm_mon < lt_item_day.tm_mon ||
-          (lt_day.tm_mon == lt_item_day.tm_mon &&
-           lt_day.tm_mday < lt_item_day.tm_mday))
-        diff++;
-      lt_item_day.tm_year = lt_day.tm_year - diff;
-      break;
-    default:
-      EXIT (_("unknown item type"));
-    }
+  span = (item_start - mktime(&lt_item_day) + item_dur - 1) / DAYINSEC;
+
+  switch (rpt_type) {
+  case RECUR_DAILY:
+    diff = diff_days(lt_item_day, lt_day) % rpt_freq;
+    lt_item_day.tm_mday = lt_day.tm_mday - diff;
+    lt_item_day.tm_mon = lt_day.tm_mon;
+    lt_item_day.tm_year = lt_day.tm_year;
+    break;
+  case RECUR_WEEKLY:
+    diff = diff_days(lt_item_day, lt_day) % (rpt_freq * WEEKINDAYS);
+    lt_item_day.tm_mday = lt_day.tm_mday - diff;
+    lt_item_day.tm_mon = lt_day.tm_mon;
+    lt_item_day.tm_year = lt_day.tm_year;
+    break;
+  case RECUR_MONTHLY:
+    diff = diff_months(lt_item_day, lt_day) % rpt_freq;
+    if (lt_day.tm_mday < lt_item_day.tm_mday)
+      diff++;
+    lt_item_day.tm_mon = lt_day.tm_mon - diff;
+    lt_item_day.tm_year = lt_day.tm_year;
+    break;
+  case RECUR_YEARLY:
+    diff = diff_years(lt_item_day, lt_day) % rpt_freq;
+    if (lt_day.tm_mon < lt_item_day.tm_mon ||
+        (lt_day.tm_mon == lt_item_day.tm_mon &&
+         lt_day.tm_mday < lt_item_day.tm_mday))
+      diff++;
+    lt_item_day.tm_year = lt_day.tm_year - diff;
+    break;
+  default:
+    EXIT(_("unknown item type"));
+  }
 
   lt_item_day.tm_isdst = lt_day.tm_isdst;
-  t = mktime (&lt_item_day);
+  t = mktime(&lt_item_day);
 
-  if (LLIST_FIND_FIRST (item_exc, t, exc_inday))
+  if (LLIST_FIND_FIRST(item_exc, t, exc_inday))
     return 0;
 
   if (rpt_until != 0 && t > rpt_until)
     return 0;
 
-  lt_item_day = *localtime (&t);
-  diff = diff_days (lt_item_day, lt_day);
-
-  if (diff <= span)
-    {
-      if (occurrence)
-        {
-          start_date.dd = lt_item_day.tm_mday;
-          start_date.mm = lt_item_day.tm_mon + 1;
-          start_date.yyyy = lt_item_day.tm_year + 1900;
+  lt_item_day = *localtime(&t);
+  diff = diff_days(lt_item_day, lt_day);
 
-          *occurrence = date2sec (start_date, lt_item.tm_hour, lt_item.tm_min);
-        }
+  if (diff <= span) {
+    if (occurrence) {
+      start_date.dd = lt_item_day.tm_mday;
+      start_date.mm = lt_item_day.tm_mon + 1;
+      start_date.yyyy = lt_item_day.tm_year + 1900;
 
-      return 1;
+      *occurrence = date2sec(start_date, lt_item.tm_hour, lt_item.tm_min);
     }
-  else
+
+    return 1;
+  } else
     return 0;
 }
 
 unsigned
-recur_apoint_find_occurrence (struct recur_apoint *rapt, long day_start,
-                              unsigned *occurrence)
+recur_apoint_find_occurrence(struct recur_apoint *rapt, long day_start,
+                             unsigned *occurrence)
 {
   return recur_item_find_occurrence(rapt->start, rapt->dur, &rapt->exc,
                                     rapt->rpt->type, rapt->rpt->freq,
@@ -722,8 +659,8 @@ recur_apoint_find_occurrence (struct recur_apoint *rapt, long day_start,
 }
 
 unsigned
-recur_event_find_occurrence (struct recur_event *rev, long day_start,
-                             unsigned *occurrence)
+recur_event_find_occurrence(struct recur_event *rev, long day_start,
+                            unsigned *occurrence)
 {
   return recur_item_find_occurrence(rev->day, DAYINSEC, &rev->exc,
                                     rev->rpt->type, rev->rpt->freq,
@@ -732,8 +669,8 @@ recur_event_find_occurrence (struct recur_event *rev, long day_start,
 
 /* Check if a recurrent item belongs to the selected day. */
 unsigned
-recur_item_inday (long item_start, long item_dur, llist_t *item_exc,
-                  int rpt_type, int rpt_freq, long rpt_until, long day_start)
+recur_item_inday(long item_start, long item_dur, llist_t * item_exc,
+                 int rpt_type, int rpt_freq, long rpt_until, long day_start)
 {
   /* We do not need the (real) start time of the occurrence here, so just
    * ignore the buffer. */
@@ -741,15 +678,13 @@ recur_item_inday (long item_start, long item_dur, llist_t *item_exc,
                                     rpt_freq, rpt_until, day_start, NULL);
 }
 
-unsigned
-recur_apoint_inday(struct recur_apoint *rapt, long day_start)
+unsigned recur_apoint_inday(struct recur_apoint *rapt, long day_start)
 {
   return recur_item_inday(rapt->start, rapt->dur, &rapt->exc, rapt->rpt->type,
                           rapt->rpt->freq, rapt->rpt->until, day_start);
 }
 
-unsigned
-recur_event_inday(struct recur_event *rev, long day_start)
+unsigned recur_event_inday(struct recur_event *rev, long day_start)
 {
   return recur_item_inday(rev->day, DAYINSEC, &rev->exc, rev->rpt->type,
                           rev->rpt->freq, rev->rpt->until, day_start);
@@ -760,44 +695,40 @@ recur_event_inday(struct recur_event *rev, long day_start)
  * or delete only one occurence of the recurrent event.
  */
 void
-recur_event_erase (long start, unsigned num, unsigned delete_whole,
-                   enum eraseflg flag)
+recur_event_erase(long start, unsigned num, unsigned delete_whole,
+                  enum eraseflg flag)
 {
   llist_item_t *i;
 
-  i = LLIST_FIND_NTH (&recur_elist, num, start, recur_event_inday);
+  i = LLIST_FIND_NTH(&recur_elist, num, start, recur_event_inday);
 
   if (!i)
-    EXIT (_("event not found"));
-  struct recur_event *rev = LLIST_GET_DATA (i);
-
-  if (delete_whole)
-    {
-      switch (flag)
-        {
-        case ERASE_FORCE_ONLY_NOTE:
-          erase_note (&rev->note);
-          break;
-        case ERASE_CUT:
-          recur_event_free_bkp ();
-          recur_event_dup (rev, &bkp_cut_recur_event);
-          erase_note (&rev->note);
-          /* FALLTHROUGH */
-        default:
-          LLIST_REMOVE (&recur_elist, i);
-          mem_free (rev->mesg);
-          if (rev->rpt)
-            {
-              mem_free (rev->rpt);
-              rev->rpt = 0;
-            }
-          free_exc_list (&rev->exc);
-          mem_free (rev);
-          break;
-        }
+    EXIT(_("event not found"));
+  struct recur_event *rev = LLIST_GET_DATA(i);
+
+  if (delete_whole) {
+    switch (flag) {
+    case ERASE_FORCE_ONLY_NOTE:
+      erase_note(&rev->note);
+      break;
+    case ERASE_CUT:
+      recur_event_free_bkp();
+      recur_event_dup(rev, &bkp_cut_recur_event);
+      erase_note(&rev->note);
+      /* FALLTHROUGH */
+    default:
+      LLIST_REMOVE(&recur_elist, i);
+      mem_free(rev->mesg);
+      if (rev->rpt) {
+        mem_free(rev->rpt);
+        rev->rpt = 0;
+      }
+      free_exc_list(&rev->exc);
+      mem_free(rev);
+      break;
     }
-  else
-    recur_add_exc (&rev->exc, start);
+  } else
+    recur_add_exc(&rev->exc, start);
 }
 
 /*
@@ -805,55 +736,50 @@ recur_event_erase (long start, unsigned num, unsigned delete_whole,
  * or delete only one occurence of the recurrent appointment.
  */
 void
-recur_apoint_erase (long start, unsigned num, unsigned delete_whole,
-                    enum eraseflg flag)
+recur_apoint_erase(long start, unsigned num, unsigned delete_whole,
+                   enum eraseflg flag)
 {
   llist_item_t *i;
   int need_check_notify = 0;
 
-  i = LLIST_TS_FIND_NTH (&recur_alist_p, num, start, recur_apoint_inday);
+  i = LLIST_TS_FIND_NTH(&recur_alist_p, num, start, recur_apoint_inday);
 
   if (!i)
-    EXIT (_("appointment not found"));
-  struct recur_apoint *rapt = LLIST_GET_DATA (i);
-
-  LLIST_TS_LOCK (&recur_alist_p);
-  if (notify_bar () && flag != ERASE_FORCE_ONLY_NOTE)
-    need_check_notify = notify_same_recur_item (rapt);
-  if (delete_whole)
-    {
-      switch (flag)
-        {
-        case ERASE_FORCE_ONLY_NOTE:
-          erase_note (&rapt->note);
-          break;
-        case ERASE_CUT:
-          recur_apoint_free_bkp ();
-          recur_apoint_dup (rapt, &bkp_cut_recur_apoint);
-          erase_note (&rapt->note);
-          /* FALLTHROUGH */
-        default:
-          LLIST_TS_REMOVE (&recur_alist_p, i);
-          mem_free (rapt->mesg);
-          if (rapt->rpt)
-            {
-              mem_free (rapt->rpt);
-              rapt->rpt = 0;
-            }
-          free_exc_list (&rapt->exc);
-          mem_free (rapt);
-          if (need_check_notify)
-            notify_check_next_app (0);
-          break;
-        }
-    }
-  else
-    {
-      recur_add_exc (&rapt->exc, start);
+    EXIT(_("appointment not found"));
+  struct recur_apoint *rapt = LLIST_GET_DATA(i);
+
+  LLIST_TS_LOCK(&recur_alist_p);
+  if (notify_bar() && flag != ERASE_FORCE_ONLY_NOTE)
+    need_check_notify = notify_same_recur_item(rapt);
+  if (delete_whole) {
+    switch (flag) {
+    case ERASE_FORCE_ONLY_NOTE:
+      erase_note(&rapt->note);
+      break;
+    case ERASE_CUT:
+      recur_apoint_free_bkp();
+      recur_apoint_dup(rapt, &bkp_cut_recur_apoint);
+      erase_note(&rapt->note);
+      /* FALLTHROUGH */
+    default:
+      LLIST_TS_REMOVE(&recur_alist_p, i);
+      mem_free(rapt->mesg);
+      if (rapt->rpt) {
+        mem_free(rapt->rpt);
+        rapt->rpt = 0;
+      }
+      free_exc_list(&rapt->exc);
+      mem_free(rapt);
       if (need_check_notify)
-        notify_check_next_app (0);
+        notify_check_next_app(0);
+      break;
     }
-  LLIST_TS_UNLOCK (&recur_alist_p);
+  } else {
+    recur_add_exc(&rapt->exc, start);
+    if (need_check_notify)
+      notify_check_next_app(0);
+  }
+  LLIST_TS_UNLOCK(&recur_alist_p);
 }
 
 /*
@@ -863,8 +789,7 @@ recur_apoint_erase (long start, unsigned num, unsigned delete_whole,
  *	o repetition end date
  * and then delete the selected item to recreate it as a recurrent one
  */
-void
-recur_repeat_item (void)
+void recur_repeat_item(void)
 {
   struct tm *lt;
   time_t t;
@@ -882,22 +807,19 @@ recur_repeat_item (void)
   const char *mesg_freq_1 = _("Enter the repetition frequence:");
   const char *mesg_wrong_freq = _("The frequence you entered is not valid.");
   const char *mesg_until_1 =
-    _("Enter the ending date: [%s] or '0' for an endless repetition");
+      _("Enter the ending date: [%s] or '0' for an endless repetition");
   const char *mesg_wrong_1 = _("The entered date is not valid.");
   const char *mesg_wrong_2 =
-    _("Possible formats are [%s] or '0' for an endless repetition");
+      _("Possible formats are [%s] or '0' for an endless repetition");
   const char *wrong_type_1 = _("This item is already a repeated one.");
   const char *wrong_type_2 = _("Press [ENTER] to continue.");
   const char *mesg_older =
-    _("Sorry, the date you entered is older than the item start time.");
+      _("Sorry, the date you entered is older than the item start time.");
 
   char msg_asktype[BUFSIZ];
-    snprintf (msg_asktype, BUFSIZ, "%s %s, %s, %s, %s",
-              msg_rpt_prefix,
-              msg_rpt_daily,
-              msg_rpt_weekly,
-              msg_rpt_monthly,
-              msg_rpt_yearly);
+  snprintf(msg_asktype, BUFSIZ, "%s %s, %s, %s, %s",
+           msg_rpt_prefix,
+           msg_rpt_daily, msg_rpt_weekly, msg_rpt_monthly, msg_rpt_yearly);
 
   int type = 0, freq = 0;
   int item_nb;
@@ -905,151 +827,123 @@ recur_repeat_item (void)
   struct recur_apoint *ra;
   long until, date;
 
-  item_nb = apoint_hilt ();
-  p = day_get_item (item_nb);
-  if (p->type != APPT && p->type != EVNT)
-    {
-      status_mesg (wrong_type_1, wrong_type_2);
-      wgetch (win[STA].p);
-      return;
-    }
-
-  switch (status_ask_choice (msg_asktype, msg_type_choice, 4))
-    {
-    case 1:
-      type = RECUR_DAILY;
-      break;
-    case 2:
-      type = RECUR_WEEKLY;
-      break;
-    case 3:
-      type = RECUR_MONTHLY;
-      break;
-    case 4:
-      type = RECUR_YEARLY;
-      break;
-    default:
+  item_nb = apoint_hilt();
+  p = day_get_item(item_nb);
+  if (p->type != APPT && p->type != EVNT) {
+    status_mesg(wrong_type_1, wrong_type_2);
+    wgetch(win[STA].p);
+    return;
+  }
+
+  switch (status_ask_choice(msg_asktype, msg_type_choice, 4)) {
+  case 1:
+    type = RECUR_DAILY;
+    break;
+  case 2:
+    type = RECUR_WEEKLY;
+    break;
+  case 3:
+    type = RECUR_MONTHLY;
+    break;
+  case 4:
+    type = RECUR_YEARLY;
+    break;
+  default:
+    return;
+  }
+
+  while (freq == 0) {
+    status_mesg(mesg_freq_1, "");
+    if (getstring(win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) {
+      freq = atoi(user_input);
+      if (freq == 0) {
+        status_mesg(mesg_wrong_freq, wrong_type_2);
+        wgetch(win[STA].p);
+      }
+      user_input[0] = '\0';
+    } else
       return;
-    }
-
-  while (freq == 0)
-    {
-      status_mesg (mesg_freq_1, "");
-      if (getstring (win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID)
-        {
-          freq = atoi (user_input);
-          if (freq == 0)
-            {
-              status_mesg (mesg_wrong_freq, wrong_type_2);
-              wgetch (win[STA].p);
-            }
-          user_input[0] = '\0';
-        }
-      else
-        return;
-    }
-
-  while (!date_entered)
-    {
-      snprintf (outstr, BUFSIZ, mesg_until_1,
-                DATEFMT_DESC (conf.input_datefmt));
-      status_mesg (_(outstr), "");
-      if (getstring (win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID)
-        {
-          if (strlen (user_input) == 1 && strcmp (user_input, "0") == 0)
-            {
-              until = 0;
-              date_entered = 1;
-            }
-          else
-            {
-              if (parse_date (user_input, conf.input_datefmt,
-                              &year, &month, &day, calendar_get_slctd_day ()))
-                {
-                  t = p->start;
-                  lt = localtime (&t);
-                  until_date.dd = day;
-                  until_date.mm = month;
-                  until_date.yyyy = year;
-                  until = date2sec (until_date, lt->tm_hour, lt->tm_min);
-                  if (until < p->start)
-                    {
-                      status_mesg (mesg_older, wrong_type_2);
-                      wgetch (win[STA].p);
-                      date_entered = 0;
-                    }
-                  else
-                    {
-                      date_entered = 1;
-                    }
-                }
-              else
-                {
-                  snprintf (outstr, BUFSIZ, mesg_wrong_2,
-                            DATEFMT_DESC (conf.input_datefmt));
-                  status_mesg (mesg_wrong_1, _(outstr));
-                  wgetch (win[STA].p);
-                  date_entered = 0;
-                }
-            }
+  }
+
+  while (!date_entered) {
+    snprintf(outstr, BUFSIZ, mesg_until_1, DATEFMT_DESC(conf.input_datefmt));
+    status_mesg(_(outstr), "");
+    if (getstring(win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) {
+      if (strlen(user_input) == 1 && strcmp(user_input, "0") == 0) {
+        until = 0;
+        date_entered = 1;
+      } else {
+        if (parse_date(user_input, conf.input_datefmt,
+                       &year, &month, &day, calendar_get_slctd_day())) {
+          t = p->start;
+          lt = localtime(&t);
+          until_date.dd = day;
+          until_date.mm = month;
+          until_date.yyyy = year;
+          until = date2sec(until_date, lt->tm_hour, lt->tm_min);
+          if (until < p->start) {
+            status_mesg(mesg_older, wrong_type_2);
+            wgetch(win[STA].p);
+            date_entered = 0;
+          } else {
+            date_entered = 1;
+          }
+        } else {
+          snprintf(outstr, BUFSIZ, mesg_wrong_2,
+                   DATEFMT_DESC(conf.input_datefmt));
+          status_mesg(mesg_wrong_1, _(outstr));
+          wgetch(win[STA].p);
+          date_entered = 0;
         }
-      else
-        return;
-    }
-
-  date = calendar_get_slctd_day_sec ();
-  if (p->type == EVNT)
-    {
-      recur_event_new (p->mesg, p->note, p->start, p->evnt_id, type, freq,
-                       until, NULL);
-    }
-  else if (p->type == APPT)
-    {
-      ra = recur_apoint_new (p->mesg, p->note, p->start, p->appt_dur,
-                             p->state, type, freq, until, NULL);
-      if (notify_bar ())
-        notify_check_repeated (ra);
-    }
-  else
-    {
-      EXIT (_("wrong item type"));
-      /* NOTREACHED */
-    }
-  day_erase_item (date, item_nb, ERASE_FORCE);
+      }
+    } else
+      return;
+  }
+
+  date = calendar_get_slctd_day_sec();
+  if (p->type == EVNT) {
+    recur_event_new(p->mesg, p->note, p->start, p->evnt_id, type, freq,
+                    until, NULL);
+  } else if (p->type == APPT) {
+    ra = recur_apoint_new(p->mesg, p->note, p->start, p->appt_dur,
+                          p->state, type, freq, until, NULL);
+    if (notify_bar())
+      notify_check_repeated(ra);
+  } else {
+    EXIT(_("wrong item type"));
+    /* NOTREACHED */
+  }
+  day_erase_item(date, item_nb, ERASE_FORCE);
 }
 
 /*
  * Read days for which recurrent items must not be repeated
  * (such days are called exceptions).
  */
-void
-recur_exc_scan (llist_t *lexc, FILE *data_file)
+void recur_exc_scan(llist_t * lexc, FILE * data_file)
 {
   int c = 0;
   struct tm day;
 
-  LLIST_INIT (lexc);
-  while ((c = getc (data_file)) == '!')
-    {
-      ungetc (c, data_file);
-      if (fscanf (data_file, "!%d / %d / %d ",
-                  &day.tm_mon, &day.tm_mday, &day.tm_year) != 3)
-        {
-          EXIT (_("syntax error in item date"));
-        }
-      day.tm_hour = 0;
-      day.tm_min = day.tm_sec = 0;
-      day.tm_isdst = -1;
-      day.tm_year -= 1900;
-      day.tm_mon--;
-      struct excp *exc = mem_malloc (sizeof (struct excp));
-      exc->st = mktime (&day);
-      LLIST_ADD (lexc, exc);
+  LLIST_INIT(lexc);
+  while ((c = getc(data_file)) == '!') {
+    ungetc(c, data_file);
+    if (fscanf(data_file, "!%d / %d / %d ",
+               &day.tm_mon, &day.tm_mday, &day.tm_year) != 3) {
+      EXIT(_("syntax error in item date"));
     }
+    day.tm_hour = 0;
+    day.tm_min = day.tm_sec = 0;
+    day.tm_isdst = -1;
+    day.tm_year -= 1900;
+    day.tm_mon--;
+    struct excp *exc = mem_malloc(sizeof(struct excp));
+    exc->st = mktime(&day);
+    LLIST_ADD(lexc, exc);
+  }
 }
 
-static int
-recur_apoint_starts_before (struct recur_apoint *rapt, long time)
+static int recur_apoint_starts_before(struct recur_apoint *rapt, long time)
 {
   return rapt->start < time;
 }
@@ -1058,135 +952,126 @@ recur_apoint_starts_before (struct recur_apoint *rapt, long time)
  * Look in the appointment list if we have an item which starts before the item
  * stored in the notify_app structure (which is the next item to be notified).
  */
-struct notify_app *
-recur_apoint_check_next (struct notify_app *app, long start, long day)
+struct notify_app *recur_apoint_check_next(struct notify_app *app, long start,
+                                           long day)
 {
   llist_item_t *i;
   unsigned real_recur_start_time;
 
-  LLIST_TS_LOCK (&recur_alist_p);
-  LLIST_TS_FIND_FOREACH (&recur_alist_p, app->time, recur_apoint_starts_before, i)
-    {
-      struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
-
-      if (recur_apoint_find_occurrence (rapt, day, &real_recur_start_time) &&
-          real_recur_start_time > start)
-        {
-          app->time = real_recur_start_time;
-          app->txt = mem_strdup (rapt->mesg);
-          app->state = rapt->state;
-          app->got_app = 1;
-        }
+  LLIST_TS_LOCK(&recur_alist_p);
+  LLIST_TS_FIND_FOREACH(&recur_alist_p, app->time, recur_apoint_starts_before,
+                        i) {
+    struct recur_apoint *rapt = LLIST_TS_GET_DATA(i);
+
+    if (recur_apoint_find_occurrence(rapt, day, &real_recur_start_time) &&
+        real_recur_start_time > start) {
+      app->time = real_recur_start_time;
+      app->txt = mem_strdup(rapt->mesg);
+      app->state = rapt->state;
+      app->got_app = 1;
     }
-  LLIST_TS_UNLOCK (&recur_alist_p);
+  }
+  LLIST_TS_UNLOCK(&recur_alist_p);
 
   return app;
 }
 
 /* Returns a structure containing the selected recurrent appointment. */
-struct recur_apoint *
-recur_get_apoint (long date, int num)
+struct recur_apoint *recur_get_apoint(long date, int num)
 {
-  llist_item_t *i = LLIST_TS_FIND_NTH (&recur_alist_p, num, date,
+  llist_item_t *i = LLIST_TS_FIND_NTH(&recur_alist_p, num, date,
                                       recur_apoint_inday);
 
   if (i)
-    return LLIST_TS_GET_DATA (i);
+    return LLIST_TS_GET_DATA(i);
 
-  EXIT (_("item not found"));
+  EXIT(_("item not found"));
   /* NOTREACHED */
 }
 
 /* Returns a structure containing the selected recurrent event. */
-struct recur_event *
-recur_get_event (long date, int num)
+struct recur_event *recur_get_event(long date, int num)
 {
-  llist_item_t *i = LLIST_FIND_NTH (&recur_elist, num, date,
-                                    recur_event_inday);
+  llist_item_t *i = LLIST_FIND_NTH(&recur_elist, num, date,
+                                   recur_event_inday);
 
   if (i)
-    return LLIST_GET_DATA (i);
+    return LLIST_GET_DATA(i);
 
-  EXIT (_("item not found"));
+  EXIT(_("item not found"));
   /* NOTREACHED */
 }
 
 /* Switch recurrent item notification state. */
-void
-recur_apoint_switch_notify (long date, int recur_nb)
+void recur_apoint_switch_notify(long date, int recur_nb)
 {
   llist_item_t *i;
 
-  LLIST_TS_LOCK (&recur_alist_p);
-  i = LLIST_TS_FIND_NTH (&recur_alist_p, recur_nb, date, recur_apoint_inday);
+  LLIST_TS_LOCK(&recur_alist_p);
+  i = LLIST_TS_FIND_NTH(&recur_alist_p, recur_nb, date, recur_apoint_inday);
 
   if (!i)
-    EXIT (_("item not found"));
-  struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
+    EXIT(_("item not found"));
+  struct recur_apoint *rapt = LLIST_TS_GET_DATA(i);
 
   rapt->state ^= APOINT_NOTIFY;
 
-  if (notify_bar ())
-    notify_check_repeated (rapt);
+  if (notify_bar())
+    notify_check_repeated(rapt);
 
-  LLIST_TS_UNLOCK (&recur_alist_p);
+  LLIST_TS_UNLOCK(&recur_alist_p);
 }
 
-void
-recur_event_paste_item (void)
+void recur_event_paste_item(void)
 {
   long new_start, time_shift;
   llist_item_t *i;
 
-  new_start = date2sec (*calendar_get_slctd_day (), 0, 0);
+  new_start = date2sec(*calendar_get_slctd_day(), 0, 0);
   time_shift = new_start - bkp_cut_recur_event.day;
 
   bkp_cut_recur_event.day += time_shift;
   if (bkp_cut_recur_event.rpt->until != 0)
     bkp_cut_recur_event.rpt->until += time_shift;
-  LLIST_FOREACH (&bkp_cut_recur_event.exc, i)
-    {
-      struct excp *exc = LLIST_GET_DATA (i);
-      exc->st += time_shift;
-    }
-
-  recur_event_new (bkp_cut_recur_event.mesg, bkp_cut_recur_event.note,
-                   bkp_cut_recur_event.day, bkp_cut_recur_event.id,
-                   bkp_cut_recur_event.rpt->type,
-                   bkp_cut_recur_event.rpt->freq,
-                   bkp_cut_recur_event.rpt->until, &bkp_cut_recur_event.exc);
-  recur_event_free_bkp ();
+  LLIST_FOREACH(&bkp_cut_recur_event.exc, i) {
+    struct excp *exc = LLIST_GET_DATA(i);
+    exc->st += time_shift;
+  }
+
+  recur_event_new(bkp_cut_recur_event.mesg, bkp_cut_recur_event.note,
+                  bkp_cut_recur_event.day, bkp_cut_recur_event.id,
+                  bkp_cut_recur_event.rpt->type,
+                  bkp_cut_recur_event.rpt->freq,
+                  bkp_cut_recur_event.rpt->until, &bkp_cut_recur_event.exc);
+  recur_event_free_bkp();
 }
 
-void
-recur_apoint_paste_item (void)
+void recur_apoint_paste_item(void)
 {
   long new_start, time_shift;
   llist_item_t *i;
 
-  new_start = date2sec (*calendar_get_slctd_day (),
-                        get_item_hour (bkp_cut_recur_apoint.start),
-                        get_item_min (bkp_cut_recur_apoint.start));
+  new_start = date2sec(*calendar_get_slctd_day(),
+                       get_item_hour(bkp_cut_recur_apoint.start),
+                       get_item_min(bkp_cut_recur_apoint.start));
   time_shift = new_start - bkp_cut_recur_apoint.start;
 
   bkp_cut_recur_apoint.start += time_shift;
   if (bkp_cut_recur_apoint.rpt->until != 0)
     bkp_cut_recur_apoint.rpt->until += time_shift;
-  LLIST_FOREACH (&bkp_cut_recur_event.exc, i)
-    {
-      struct excp *exc = LLIST_GET_DATA (i);
-      exc->st += time_shift;
-    }
+  LLIST_FOREACH(&bkp_cut_recur_event.exc, i) {
+    struct excp *exc = LLIST_GET_DATA(i);
+    exc->st += time_shift;
+  }
 
-  recur_apoint_new (bkp_cut_recur_apoint.mesg, bkp_cut_recur_apoint.note,
-                    bkp_cut_recur_apoint.start, bkp_cut_recur_apoint.dur,
-                    bkp_cut_recur_apoint.state, bkp_cut_recur_apoint.rpt->type,
-                    bkp_cut_recur_apoint.rpt->freq,
-                    bkp_cut_recur_apoint.rpt->until,
-                    &bkp_cut_recur_apoint.exc);
+  recur_apoint_new(bkp_cut_recur_apoint.mesg, bkp_cut_recur_apoint.note,
+                   bkp_cut_recur_apoint.start, bkp_cut_recur_apoint.dur,
+                   bkp_cut_recur_apoint.state, bkp_cut_recur_apoint.rpt->type,
+                   bkp_cut_recur_apoint.rpt->freq,
+                   bkp_cut_recur_apoint.rpt->until, &bkp_cut_recur_apoint.exc);
 
-  if (notify_bar ())
-    notify_check_repeated (&bkp_cut_recur_apoint);
+  if (notify_bar())
+    notify_check_repeated(&bkp_cut_recur_apoint);
 
-  recur_apoint_free_bkp ();
+  recur_apoint_free_bkp();
 }