Use tabs instead of spaces for indentation

This completes our switch to the Linux kernel coding style. Note that we
still use deeply nested constructs at some places which need to be fixed
up later.

Converted using the `Lindent` script from the Linux kernel code base,
along with some manual fixes.

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

1 files changed, 142 insertions, 139 deletions

diff --git a/src/mem.c b/src/mem.c
index 8889cc0..a351818 100644
--- a/src/mem.c
+++ b/src/mem.c
@@ -44,10 +44,10 @@
 #ifdef CALCURSE_MEMORY_DEBUG
 
 enum {
-  BLK_STATE,
-  BLK_SIZE,
-  BLK_ID,
-  EXTRA_SPACE_START
+	BLK_STATE,
+	BLK_SIZE,
+	BLK_ID,
+	EXTRA_SPACE_START
 };
 
 #define EXTRA_SPACE_END    1
@@ -57,14 +57,14 @@ enum {
 #define MAGIC_FREE         0xdf
 
 struct mem_blk {
-  unsigned id, size;
-  const char *pos;
-  struct mem_blk *next;
+	unsigned id, size;
+	const char *pos;
+	struct mem_blk *next;
 };
 
 struct mem_stats {
-  unsigned ncall, nalloc, nfree;
-  struct mem_blk *blk;
+	unsigned ncall, nalloc, nfree;
+	struct mem_blk *blk;
 };
 
 static struct mem_stats mstats;
@@ -73,229 +73,232 @@ static struct mem_stats mstats;
 
 void *xmalloc(size_t size)
 {
-  void *p;
+	void *p;
 
-  EXIT_IF(size == 0, _("xmalloc: zero size"));
-  p = malloc(size);
-  EXIT_IF(p == NULL, _("xmalloc: out of memory"));
+	EXIT_IF(size == 0, _("xmalloc: zero size"));
+	p = malloc(size);
+	EXIT_IF(p == NULL, _("xmalloc: out of memory"));
 
-  return p;
+	return p;
 }
 
 void *xcalloc(size_t nmemb, size_t size)
 {
-  void *p;
+	void *p;
 
-  EXIT_IF(nmemb == 0 || size == 0, _("xcalloc: zero size"));
-  EXIT_IF(SIZE_MAX / nmemb < size, _("xcalloc: overflow"));
-  p = calloc(nmemb, size);
-  EXIT_IF(p == NULL, _("xcalloc: out of memory"));
+	EXIT_IF(nmemb == 0 || size == 0, _("xcalloc: zero size"));
+	EXIT_IF(SIZE_MAX / nmemb < size, _("xcalloc: overflow"));
+	p = calloc(nmemb, size);
+	EXIT_IF(p == NULL, _("xcalloc: out of memory"));
 
-  return p;
+	return p;
 }
 
 void *xrealloc(void *ptr, size_t nmemb, size_t size)
 {
-  void *new_ptr;
-  size_t new_size;
+	void *new_ptr;
+	size_t new_size;
 
-  new_size = nmemb * size;
-  EXIT_IF(new_size == 0, _("xrealloc: zero size"));
-  EXIT_IF(SIZE_MAX / nmemb < size, _("xrealloc: overflow"));
-  new_ptr = realloc(ptr, new_size);
-  EXIT_IF(new_ptr == NULL, _("xrealloc: out of memory"));
+	new_size = nmemb * size;
+	EXIT_IF(new_size == 0, _("xrealloc: zero size"));
+	EXIT_IF(SIZE_MAX / nmemb < size, _("xrealloc: overflow"));
+	new_ptr = realloc(ptr, new_size);
+	EXIT_IF(new_ptr == NULL, _("xrealloc: out of memory"));
 
-  return new_ptr;
+	return new_ptr;
 }
 
 char *xstrdup(const char *str)
 {
-  size_t len;
-  char *cp;
+	size_t len;
+	char *cp;
 
-  len = strlen(str) + 1;
-  cp = xmalloc(len);
+	len = strlen(str) + 1;
+	cp = xmalloc(len);
 
-  return strncpy(cp, str, len);
+	return strncpy(cp, str, len);
 }
 
 void xfree(void *p)
 {
-  EXIT_IF(p == NULL, _("xfree: null pointer"));
-  free(p);
+	EXIT_IF(p == NULL, _("xfree: null pointer"));
+	free(p);
 }
 
 #ifdef CALCURSE_MEMORY_DEBUG
 
 static unsigned stats_add_blk(size_t size, const char *pos)
 {
-  struct mem_blk *o, **i;
+	struct mem_blk *o, **i;
 
-  o = malloc(sizeof(*o));
-  EXIT_IF(o == NULL, _("could not allocate memory to store block info"));
+	o = malloc(sizeof(*o));
+	EXIT_IF(o == NULL,
+		_("could not allocate memory to store block info"));
 
-  mstats.ncall++;
+	mstats.ncall++;
 
-  o->pos = pos;
-  o->size = (unsigned)size;
-  o->next = 0;
+	o->pos = pos;
+	o->size = (unsigned)size;
+	o->next = 0;
 
-  for (i = &mstats.blk; *i; i = &(*i)->next) ;
-  o->id = mstats.ncall;
-  *i = o;
+	for (i = &mstats.blk; *i; i = &(*i)->next) ;
+	o->id = mstats.ncall;
+	*i = o;
 
-  return o->id;
+	return o->id;
 }
 
 static void stats_del_blk(unsigned id)
 {
-  struct mem_blk *o, **i;
-
-  i = &mstats.blk;
-  for (o = mstats.blk; o; o = o->next) {
-    if (o->id == id) {
-      *i = o->next;
-      free(o);
-      return;
-    }
-    i = &o->next;
-  }
-
-  EXIT(_("Block not found"));
-  /* NOTREACHED */
+	struct mem_blk *o, **i;
+
+	i = &mstats.blk;
+	for (o = mstats.blk; o; o = o->next) {
+		if (o->id == id) {
+			*i = o->next;
+			free(o);
+			return;
+		}
+		i = &o->next;
+	}
+
+	EXIT(_("Block not found"));
+	/* NOTREACHED */
 }
 
 void *dbg_malloc(size_t size, const char *pos)
 {
-  unsigned *buf;
+	unsigned *buf;
 
-  if (size == 0)
-    return NULL;
+	if (size == 0)
+		return NULL;
 
-  size = EXTRA_SPACE + (size + sizeof(unsigned) - 1) / sizeof(unsigned);
-  buf = xmalloc(size * sizeof(unsigned));
+	size =
+	    EXTRA_SPACE + (size + sizeof(unsigned) - 1) / sizeof(unsigned);
+	buf = xmalloc(size * sizeof(unsigned));
 
-  buf[BLK_STATE] = MAGIC_ALLOC; /* state of the block */
-  buf[BLK_SIZE] = size;         /* size of the block */
-  buf[BLK_ID] = stats_add_blk(size, pos);       /* identify a block by its id */
-  buf[size - 1] = buf[BLK_ID];  /* mark at end of block */
+	buf[BLK_STATE] = MAGIC_ALLOC;	/* state of the block */
+	buf[BLK_SIZE] = size;	/* size of the block */
+	buf[BLK_ID] = stats_add_blk(size, pos);	/* identify a block by its id */
+	buf[size - 1] = buf[BLK_ID];	/* mark at end of block */
 
-  mstats.nalloc += size;
+	mstats.nalloc += size;
 
-  return (void *)(buf + EXTRA_SPACE_START);
+	return (void *)(buf + EXTRA_SPACE_START);
 }
 
 void *dbg_calloc(size_t nmemb, size_t size, const char *pos)
 {
-  void *buf;
+	void *buf;
 
-  if (!nmemb || !size)
-    return NULL;
+	if (!nmemb || !size)
+		return NULL;
 
-  EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
+	EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
 
-  size *= nmemb;
-  if ((buf = dbg_malloc(size, pos)) == NULL)
-    return NULL;
+	size *= nmemb;
+	if ((buf = dbg_malloc(size, pos)) == NULL)
+		return NULL;
 
-  memset(buf, 0, size);
+	memset(buf, 0, size);
 
-  return buf;
+	return buf;
 }
 
 void *dbg_realloc(void *ptr, size_t nmemb, size_t size, const char *pos)
 {
-  unsigned *buf, old_size, new_size, cpy_size;
+	unsigned *buf, old_size, new_size, cpy_size;
 
-  if (ptr == NULL)
-    return NULL;
+	if (ptr == NULL)
+		return NULL;
 
-  new_size = nmemb * size;
-  if (new_size == 0)
-    return NULL;
+	new_size = nmemb * size;
+	if (new_size == 0)
+		return NULL;
 
-  EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
+	EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
 
-  if ((buf = dbg_malloc(new_size, pos)) == NULL)
-    return NULL;
+	if ((buf = dbg_malloc(new_size, pos)) == NULL)
+		return NULL;
 
-  old_size = *((unsigned *)ptr - EXTRA_SPACE_START + BLK_SIZE);
-  cpy_size = (old_size > new_size) ? new_size : old_size;
-  memmove(buf, ptr, cpy_size);
+	old_size = *((unsigned *)ptr - EXTRA_SPACE_START + BLK_SIZE);
+	cpy_size = (old_size > new_size) ? new_size : old_size;
+	memmove(buf, ptr, cpy_size);
 
-  mem_free(ptr);
+	mem_free(ptr);
 
-  return (void *)buf;
+	return (void *)buf;
 }
 
 char *dbg_strdup(const char *s, const char *pos)
 {
-  size_t size;
-  char *buf;
+	size_t size;
+	char *buf;
 
-  if (s == NULL)
-    return NULL;
+	if (s == NULL)
+		return NULL;
 
-  size = strlen(s);
-  if ((buf = dbg_malloc(size + 1, pos)) == NULL)
-    return NULL;
+	size = strlen(s);
+	if ((buf = dbg_malloc(size + 1, pos)) == NULL)
+		return NULL;
 
-  return strncpy(buf, s, size + 1);
+	return strncpy(buf, s, size + 1);
 }
 
 void dbg_free(void *ptr, const char *pos)
 {
-  unsigned *buf, size;
+	unsigned *buf, size;
 
-  EXIT_IF(ptr == NULL, _("dbg_free: null pointer at %s"), pos);
+	EXIT_IF(ptr == NULL, _("dbg_free: null pointer at %s"), pos);
 
-  buf = (unsigned *)ptr - EXTRA_SPACE_START;
-  size = buf[BLK_SIZE];
+	buf = (unsigned *)ptr - EXTRA_SPACE_START;
+	size = buf[BLK_SIZE];
 
-  EXIT_IF(buf[BLK_STATE] == MAGIC_FREE,
-          _("block seems already freed at %s"), pos);
-  EXIT_IF(buf[BLK_STATE] != MAGIC_ALLOC, _("corrupt block header at %s"), pos);
-  EXIT_IF(buf[size - 1] != buf[BLK_ID],
-          _("corrupt block end at %s, (end = %u, should be %d)"), pos,
-          buf[size - 1], buf[BLK_ID]);
+	EXIT_IF(buf[BLK_STATE] == MAGIC_FREE,
+		_("block seems already freed at %s"), pos);
+	EXIT_IF(buf[BLK_STATE] != MAGIC_ALLOC,
+		_("corrupt block header at %s"), pos);
+	EXIT_IF(buf[size - 1] != buf[BLK_ID],
+		_("corrupt block end at %s, (end = %u, should be %d)"),
+		pos, buf[size - 1], buf[BLK_ID]);
 
-  buf[0] = MAGIC_FREE;
+	buf[0] = MAGIC_FREE;
 
-  stats_del_blk(buf[BLK_ID]);
+	stats_del_blk(buf[BLK_ID]);
 
-  free(buf);
-  mstats.nfree += size;
+	free(buf);
+	mstats.nfree += size;
 }
 
 static void dump_block_info(struct mem_blk *blk)
 {
-  if (blk == NULL)
-    return;
-
-  puts(_("---==== MEMORY BLOCK ====----------------\n"));
-  printf(_("            id: %u\n"), blk->id);
-  printf(_("          size: %u\n"), blk->size);
-  printf(_("  allocated in: %s\n"), blk->pos);
-  puts(_("-----------------------------------------\n"));
+	if (blk == NULL)
+		return;
+
+	puts(_("---==== MEMORY BLOCK ====----------------\n"));
+	printf(_("            id: %u\n"), blk->id);
+	printf(_("          size: %u\n"), blk->size);
+	printf(_("  allocated in: %s\n"), blk->pos);
+	puts(_("-----------------------------------------\n"));
 }
 
 void mem_stats(void)
 {
-  putchar('\n');
-  puts(_("+------------------------------+\n"));
-  puts(_("| calcurse memory usage report |\n"));
-  puts(_("+------------------------------+\n"));
-  printf(_("  number of calls: %u\n"), mstats.ncall);
-  printf(_(" allocated blocks: %u\n"), mstats.nalloc);
-  printf(_("   unfreed blocks: %u\n"), mstats.nalloc - mstats.nfree);
-  putchar('\n');
-
-  if (mstats.nfree < mstats.nalloc) {
-    struct mem_blk *blk;
-
-    for (blk = mstats.blk; blk; blk = blk->next)
-      dump_block_info(blk);
-  }
+	putchar('\n');
+	puts(_("+------------------------------+\n"));
+	puts(_("| calcurse memory usage report |\n"));
+	puts(_("+------------------------------+\n"));
+	printf(_("  number of calls: %u\n"), mstats.ncall);
+	printf(_(" allocated blocks: %u\n"), mstats.nalloc);
+	printf(_("   unfreed blocks: %u\n"), mstats.nalloc - mstats.nfree);
+	putchar('\n');
+
+	if (mstats.nfree < mstats.nalloc) {
+		struct mem_blk *blk;
+
+		for (blk = mstats.blk; blk; blk = blk->next)
+			dump_block_info(blk);
+	}
 }
 
 #endif /* CALCURSE_MEMORY_DEBUG */