bug#20778: Flush left indentation in c-mode

[Bruce Korb <bruce.korb@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 733 bytes --]

Here is a short program that went into this weirdo mode several times
fairly quickly.
Adding #include directives might be involved, but maybe not.  Again,
the same symptom:
everything goes flush left until I close out and re-visit the file.
So, when you first visit
the file, I am sure it will indent properly.  And just because you
fiddle it, it doesn't mean
it will stop indenting properly.  I do not know what the trigger
mechanism is.  I just
know it was much more frequent (several times in a few minutes).

Again, "linux" style:

$ cat ../.dir-locals.el

(
 (nil . ((indent-tabs-mode . t)
         (tab-width . 8)
         (show-trailing-whitespace . t)
         (fill-column . 132)))

 (c-mode . ((c-file-style . "linux")))
)

[-- Attachment #2: fix-tabs.c --]
[-- Type: text/x-csrc, Size: 1803 bytes --]


#include <sys/types.h>
#include <sys/stat.h>

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define NL  '\n'
#define NUL '\0'
#define HT  '\t'

static void
fserr(char const * fn, char const * op)
{
	char const * err = strerror(errno);

	fprintf(stderr, "fs error %u (%s) %s on %s\n",
		errno, err, op, fn);
	exit(EXIT_FAILURE);
}

static inline char *
detab(char * line)
{
	static union {
		unsigned long	spaces;
		unsigned char	sp[sizeof(unsigned long)];
	} const u = { .sp = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' } };
	int tab_ct = 0;
	unsigned long * lp = (void *)line;

	while (*lp == u.spaces) {
		tab_ct++;
		lp++;
	}

	line = (char *)lp;

	// Trim trailing white space
	{
		char * eol  = line + strlen(line);
		while ((eol > line) && isspace((unsigned)eol[-1]))
			eol--;
		*(eol++) = NL;
		*eol     = NUL;
		if (eol == line + 1)
			return line; // blank line
	}

	// insert "tab_ct" tab characters before the point where "line" points
	//
	while (tab_ct-- > 0)
		*(--line) = HT;
	return line;
}

static inline void
fix_file(char const * fname)
{
	char line[0x2000]; // any line over 8K deserves being mangled.

	FILE * ifp = fopen(fname, "r");

	if (ifp == NULL)
		fserr("open-read", fname);

	char tpl[] = "fix-tabs-XXXXXX";
	int fd = mkstemp(tpl);

	if (fd < 0)
		fserr("mkstemp", tpl);

	FILE * ofp = fdopen(fd, "w");

	if (ofp == NULL)
		fserr("open-write", tpl);

	for (;; ) {
		char * p = fgets(line, sizeof(line), ifp);
		if (p == NULL)
			break;
		fputs(detab(line), ofp);
	}
	{
		struct stat sb;
		if (fstat(fileno(ifp), &sb) == 0)
			fchmod(fd, sb.st_mode);
	}
	fclose(ifp);
	fclose(ofp);
	unlink(fname);
	rename(tpl, fname);
}

int
main(int argc, char ** argv)
{
	while (--argc > 0)
		fix_file(*(++argv));
}