Doc/ttman.c - cmus in C* Music Player

/*
 * ttman - text to man converter
 *
 * Copyright 2006 Timo Hirvonen <tihirvon@gmail.com>
 *
 * This file is licensed under the GPLv2.
 */
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

struct token {
	struct token *next;
	struct token *prev;
	enum {
		TOK_TEXT,	// max one line w/o \n
		TOK_NL,		// \n
		TOK_ITALIC,	// `
		TOK_BOLD,	// *
		TOK_INDENT,	// \t

		// keywords (@...)
		TOK_H1,
		TOK_H2,
		TOK_LI,
		TOK_BR,
		TOK_PRE,
		TOK_ENDPRE,	// must be after TOK_PRE
		TOK_RAW,
		TOK_ENDRAW,	// must be after TOK_RAW
		TOK_TITLE,	// WRITE 2 2001-12-13 "Linux 2.0.32" "Linux Programmer's Manual"
	} type;
	int line;

	// not NUL-terminated
	const char *text;
	// length of text
	int len;
};

static const char *program;
static const char *filename;
static char tmp_file[1024];
static FILE *outfile;
static int cur_line = 1;
static struct token head = { &head, &head, TOK_TEXT, 0, NULL, 0 };

#define CONST_STR(str) { str, sizeof(str) - 1 }
static const struct {
	const char *str;
	int len;
} token_names[] = {
	CONST_STR("text"),
	CONST_STR("nl"),
	CONST_STR("italic"),
	CONST_STR("bold"),
	CONST_STR("indent"),

	// keywords
	CONST_STR("h1"),
	CONST_STR("h2"),
	CONST_STR("li"),
	CONST_STR("br"),
	CONST_STR("pre"),
	CONST_STR("endpre"),
	CONST_STR("raw"),
	CONST_STR("endraw"),
	CONST_STR("title")
};
#define NR_TOKEN_NAMES (sizeof(token_names) / sizeof(token_names[0]))
#define BUG() die("BUG in %s\n", __FUNCTION__)

#ifdef __GNUC__
#define __NORETURN	__attribute__((__noreturn__))
#else
#define __NORETURN
#endif

static __NORETURN void quit(void)
{
	if (tmp_file[0])
		unlink(tmp_file);
	exit(1);
}

static __NORETURN void die(const char *format, ...)
{
	va_list ap;

	fprintf(stderr, "%s: ", program);
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	quit();
}

static __NORETURN void syntax(int line, const char *format, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%d: error: ", filename, line);
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	quit();
}

static inline const char *keyword_name(int type)
{
	if (type < TOK_H1 || type > TOK_TITLE)
		die("BUG: no keyword name for type %d\n", type);
	return token_names[type].str;
}

static void *xmalloc(size_t size)
{
	void *ret = malloc(size);

	if (!ret)
		die("OOM when allocating %ul bytes\n", size);
	return ret;
}

static char *memdup(const char *str, int len)
{
	char *s = xmalloc(len + 1);
	memcpy(s, str, len);
	s[len] = 0;
	return s;
}

static struct token *new_token(int type)
{
	struct token *tok = xmalloc(sizeof(struct token));

	tok->prev = NULL;
	tok->next = NULL;
	tok->type = type;
	tok->line = cur_line;
	return tok;
}

static void free_token(struct token *tok)
{
	struct token *prev = tok->prev;
	struct token *next = tok->next;

	if (tok == &head)
		BUG();

	prev->next = next;
	next->prev = prev;
	free(tok);
}

static void emit_token(struct token *tok)
{
	tok->prev = head.prev;
	tok->next = &head;
	head.prev->next = tok;
	head.prev = tok;
}

static void emit(int type)
{
	struct token *tok = new_token(type);
	tok->len = 0;
	tok->text = NULL;
	emit_token(tok);
}

static int emit_keyword(const char *buf, int size)
{
	int i, len;

	for (len = 0; len < size; len++) {
		if (!isalnum((unsigned char)buf[len]))
			break;
	}

	if (!len)
		syntax(cur_line, "keyword expected\n");

	for (i = TOK_H1; i < NR_TOKEN_NAMES; i++) {
		if (len != token_names[i].len)
			continue;
		if (!strncmp(buf, token_names[i].str, len)) {
			emit(i);
			return len;
		}
	}
	syntax(cur_line, "invalid keyword '@%s'\n", memdup(buf, len));
}

static int emit_text(const char *buf, int size)
{
	struct token *tok;
	int i;

	for (i = 0; i < size; i++) {
		int c = buf[i];
		if (c == '@' || c == '`' || c == '*' || c == '\n' || c == '\\' || c == '\t')
			break;
	}
	tok = new_token(TOK_TEXT);
	tok->text = buf;
	tok->len = i;
	emit_token(tok);
	return i;
}

static void tokenize(const char *buf, int size)
{
	int pos = 0;

	while (pos < size) {
		struct token *tok;
		int ch;

		ch = buf[pos++];
		switch (ch) {
		case '@':
			pos += emit_keyword(buf + pos, size - pos);
			break;
		case '`':
			emit(TOK_ITALIC);
			break;
		case '*':
			emit(TOK_BOLD);
			break;
		case '\n':
			emit(TOK_NL);
			cur_line++;
			break;
		case '\t':
			emit(TOK_INDENT);
			break;
		case '\\':
			tok = new_token(TOK_TEXT);
			tok->text = buf + pos;
			tok->len = 1;
			pos++;
			if (pos == size || buf[pos] == '\n') {
				// just one '\\'
				tok->text--;
			}

			if (tok->text[0] == '\\') {
				tok->text = "\\\\";
				tok->len = 2;
			}

			emit_token(tok);
			break;
		default:
			pos--;
			pos += emit_text(buf + pos, size - pos);
			break;
		}
	}
}

static int is_empty_line(const struct token *tok)
{
	while (tok != &head) {
		int i;

		switch (tok->type) {
		case TOK_TEXT:
			for (i = 0; i < tok->len; i++) {
				if (tok->text[i] != ' ')
					return 0;
			}
			break;
		case TOK_INDENT:
			break;
		case TOK_NL:
			return 1;
		default:
			return 0;
		}
		tok = tok->next;
	}
	return 1;
}

static struct token *remove_line(struct token *tok)
{
	while (tok != &head) {
		struct token *next = tok->next;
		int type = tok->type;

		free_token(tok);
		tok = next;
		if (type == TOK_NL)
			break;
	}
	return tok;
}

static struct token *skip_after(struct token *tok, int type)
{
	struct token *save = tok;

	while (tok != &head) {
		if (tok->type == type) {
			tok = tok->next;
			if (tok->type != TOK_NL)
				syntax(tok->line, "newline expected after @%s\n",
						keyword_name(type));
			return tok->next;
		}
		if (tok->type >= TOK_H1)
			syntax(tok->line, "keywords not allowed betweed @%s and @%s\n",
					keyword_name(type-1), keyword_name(type));
		tok = tok->next;
	}
	syntax(save->prev->line, "missing @%s\n", keyword_name(type));
}

static struct token *get_next_line(struct token *tok)
{
	while (tok != &head) {
		int type = tok->type;

		tok = tok->next;
		if (type == TOK_NL)
			break;
	}
	return tok;
}

static struct token *get_indent(struct token *tok, int *ip)
{
	int i = 0;

	while (tok != &head && tok->type == TOK_INDENT) {
		tok = tok->next;
		i++;
	}
	*ip = i;
	return tok;
}

// line must be non-empty
static struct token *check_line(struct token *tok, int *ip)
{
	struct token *start;
	int tok_type;

	start = tok = get_indent(tok, ip);

	tok_type = tok->type;
	switch (tok_type) {
	case TOK_TEXT:
	case TOK_BOLD:
	case TOK_ITALIC:
	case TOK_BR:
		tok = tok->next;
		while (tok != &head) {
			switch (tok->type) {
			case TOK_TEXT:
			case TOK_BOLD:
			case TOK_ITALIC:
			case TOK_BR:
			case TOK_INDENT:
				break;
			case TOK_NL:
				return start;
			default:
				syntax(tok->line, "@%s not allowed inside paragraph\n",
						keyword_name(tok->type));
			}
			tok = tok->next;
		}
		break;
	case TOK_H1:
	case TOK_H2:
	case TOK_TITLE:
		if (*ip)
			goto indentation;

		// check arguments
		tok = tok->next;
		while (tok != &head) {
			switch (tok->type) {
			case TOK_TEXT:
			case TOK_INDENT:
				break;
			case TOK_NL:
				return start;
			default:
				syntax(tok->line, "@%s can contain only text\n",
						keyword_name(tok_type));
			}
			tok = tok->next;
		}
		break;
	case TOK_LI:
		// check arguments
		tok = tok->next;
		while (tok != &head) {
			switch (tok->type) {
			case TOK_TEXT:
			case TOK_BOLD:
			case TOK_ITALIC:
			case TOK_INDENT:
				break;
			case TOK_NL:
				return start;
			default:
				syntax(tok->line, "@%s not allowed inside @li\n",
						keyword_name(tok->type));
			}
			tok = tok->next;
		}
		break;
	case TOK_PRE:
		// checked later
		break;
	case TOK_RAW:
		if (*ip)
			goto indentation;
		// checked later
		break;
	case TOK_ENDPRE:
	case TOK_ENDRAW:
		syntax(tok->line, "@%s not expected\n", keyword_name(tok->type));
		break;
	case TOK_NL:
	case TOK_INDENT:
		BUG();
		break;
	}
	return start;
indentation:
	syntax(tok->line, "indentation before @%s\n", keyword_name(tok->type));
}

static void insert_nl_before(struct token *next)
{
	struct token *prev = next->prev;
	struct token *new = new_token(TOK_NL);

	new->prev = prev;
	new->next = next;
	prev->next = new;
	next->prev = new;
}

static void normalize(void)
{
	struct token *tok = head.next;
	/*
	 * >= 0 if previous line was text (== amount of indent)
	 *   -1 if previous block was @pre (amount of indent doesn't matter)
	 *   -2 otherwise (@h1 etc., indent was 0)
	 */
	int prev_indent = -2;

	while (tok != &head) {
		struct token *start;
		int i, new_para = 0;

		// remove empty lines
		while (is_empty_line(tok)) {
			tok = remove_line(tok);
			new_para = 1;
			if (tok == &head)
				return;
		}

		// skips indent
		start = tok;
		tok = check_line(tok, &i);

		switch (tok->type) {
		case TOK_TEXT:
		case TOK_ITALIC:
		case TOK_BOLD:
		case TOK_BR:
			// normal text
			if (new_para && prev_indent >= -1) {
				// previous line/block was text or @pre
				// and there was a empty line after it
				insert_nl_before(start);
			}

			if (!new_para && prev_indent == i) {
				// join with previous line
				struct token *nl = start->prev;

				if (nl->type != TOK_NL)
					BUG();

				if ((nl->prev != &head && nl->prev->type == TOK_BR) ||
						tok->type == TOK_BR) {
					// don't convert \n after/before @br to ' '
					free_token(nl);
				} else {
					// convert "\n" to " "
					nl->type = TOK_TEXT;
					nl->text = " ";
					nl->len = 1;
				}

				// remove indent
				while (start->type == TOK_INDENT) {
					struct token *next = start->next;
					free_token(start);
					start = next;
				}
			}

			prev_indent = i;
			tok = get_next_line(tok);
			break;
		case TOK_PRE:
		case TOK_RAW:
			// these can be directly after normal text
			// but not joined with the previous line
			if (new_para && prev_indent >= -1) {
				// previous line/block was text or @pre
				// and there was a empty line after it
				insert_nl_before(start);
			}
			tok = skip_after(tok->next, tok->type + 1);
			prev_indent = -1;
			break;
		case TOK_H1:
		case TOK_H2:
		case TOK_LI:
		case TOK_TITLE:
			// remove white space after H1, H2, L1 and TITLE
			tok = tok->next;
			while (tok != &head) {
				int type = tok->type;
				struct token *next;

				if (type == TOK_TEXT) {
					while (tok->len && *tok->text == ' ') {
						tok->text++;
						tok->len--;
					}
					if (tok->len)
						break;
				}
				if (type != TOK_INDENT)
					break;

				// empty TOK_TEXT or TOK_INDENT
				next = tok->next;
				free_token(tok);
				tok = next;
			}
			// not normal text. can't be joined
			prev_indent = -2;
			tok = get_next_line(tok);
			break;
		case TOK_NL:
		case TOK_INDENT:
		case TOK_ENDPRE:
		case TOK_ENDRAW:
			BUG();
			break;
		}
	}
}

#define output(...) fprintf(outfile, __VA_ARGS__)

static void output_buf(const char *buf, int len)
{
	fwrite(buf, 1, len, outfile);
}

static void output_text(struct token *tok)
{
	char buf[1024];
	const char *str = tok->text;
	int len = tok->len;
	int pos = 0;

	while (len) {
		int c = *str++;

		if (pos >= sizeof(buf) - 1) {
			output_buf(buf, pos);
			pos = 0;
		}
		if (c == '-')
			buf[pos++] = '\\';
		buf[pos++] = c;
		len--;
	}

	if (pos)
		output_buf(buf, pos);
}

static int bold = 0;
static int italic = 0;
static int indent = 0;

static struct token *output_pre(struct token *tok)
{
	int bol = 1;

	if (tok->type != TOK_NL)
		syntax(tok->line, "newline expected after @pre\n");

	output(".nf\n");
	tok = tok->next;
	while (tok != &head) {
		if (bol) {
			int i;

			tok = get_indent(tok, &i);
			if (i != indent && tok->type != TOK_NL)
				syntax(tok->line, "indent changed in @pre\n");
		}

		switch (tok->type) {
		case TOK_TEXT:
			if (bol && tok->len && tok->text[0] == '.')
				output("\\&");
			output_text(tok);
			break;
		case TOK_NL:
			output("\n");
			bol = 1;
			tok = tok->next;
			continue;
		case TOK_ITALIC:
			output("`");
			break;
		case TOK_BOLD:
			output("*");
			break;
		case TOK_INDENT:
			// FIXME: warn
			output(" ");
			break;
		case TOK_ENDPRE:
			output(".fi\n");
			tok = tok->next;
			if (tok != &head && tok->type == TOK_NL)
				tok = tok->next;
			return tok;
		default:
			BUG();
			break;
		}
		bol = 0;
		tok = tok->next;
	}
	return tok;
}

static struct token *output_raw(struct token *tok)
{
	if (tok->type != TOK_NL)
		syntax(tok->line, "newline expected after @raw\n");

	tok = tok->next;
	while (tok != &head) {
		switch (tok->type) {
		case TOK_TEXT:
			if (tok->len == 2 && !strncmp(tok->text, "\\\\", 2)) {
				/* ugly special case
				 * "\\" (\) was converted to "\\\\" (\\) because
				 * nroff does escaping too.
				 */
				output("\\");
			} else {
				output_buf(tok->text, tok->len);
			}
			break;
		case TOK_NL:
			output("\n");
			break;
		case TOK_ITALIC:
			output("`");
			break;
		case TOK_BOLD:
			output("*");
			break;
		case TOK_INDENT:
			output("\t");
			break;
		case TOK_ENDRAW:
			tok = tok->next;
			if (tok != &head && tok->type == TOK_NL)
				tok = tok->next;
			return tok;
		default:
			BUG();
			break;
		}
		tok = tok->next;
	}
	return tok;
}

static struct token *output_para(struct token *tok)
{
	int bol = 1;

	while (tok != &head) {
		switch (tok->type) {
		case TOK_TEXT:
			output_text(tok);
			break;
		case TOK_ITALIC:
			italic ^= 1;
			if (italic) {
				output("\\fI");
			} else {
				output("\\fR");
			}
			break;
		case TOK_BOLD:
			bold ^= 1;
			if (bold) {
				output("\\fB");
			} else {
				output("\\fR");
			}
			break;
		case TOK_BR:
			if (bol) {
				output(".br\n");
			} else {
				output("\n.br\n");
			}
			bol = 1;
			tok = tok->next;
			continue;
		case TOK_NL:
			output("\n");
			return tok->next;
		case TOK_INDENT:
			output(" ");
			break;
		default:
			BUG();
			break;
		}
		bol = 0;
		tok = tok->next;
	}
	return tok;
}

static struct token *title(struct token *tok, const char *cmd)
{
	output("%s", cmd);
	return output_para(tok->next);
}

static struct token *dump_one(struct token *tok)
{
	int i;

	tok = get_indent(tok, &i);
	if (tok->type != TOK_RAW) {
		while (indent < i) {
			output(".RS\n");
			indent++;
		}
		while (indent > i) {
			output(".RE\n");
			indent--;
		}
	}

	switch (tok->type) {
	case TOK_TEXT:
	case TOK_ITALIC:
	case TOK_BOLD:
	case TOK_BR:
		if (tok->type == TOK_TEXT && tok->len && tok->text[0] == '.')
			output("\\&");
		tok = output_para(tok);
		break;
	case TOK_H1:
		tok = title(tok, ".SH ");
		break;
	case TOK_H2:
		tok = title(tok, ".SS ");
		break;
	case TOK_LI:
		tok = title(tok, ".TP\n");
		break;
	case TOK_PRE:
		tok = output_pre(tok->next);
		break;
	case TOK_RAW:
		tok = output_raw(tok->next);
		break;
	case TOK_TITLE:
		tok = title(tok, ".TH ");
		// must be after .TH
		// no hyphenation, adjust left
		output(".nh\n.ad l\n");
		break;
	case TOK_NL:
		output("\n");
		tok = tok->next;
		break;
	case TOK_ENDPRE:
	case TOK_ENDRAW:
	case TOK_INDENT:
		BUG();
		break;
	}
	return tok;
}

static void dump(void)
{
	struct token *tok = head.next;

	while (tok != &head)
		tok = dump_one(tok);
}

static void process(void)
{
	struct stat s;
	const char *buf;
	int fd;

	fd = open(filename, O_RDONLY);
	if (fd == -1)
		die("opening `%s' for reading: %s\n", filename, strerror(errno));
	fstat(fd, &s);
	if (s.st_size) {
		buf = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
		if (buf == MAP_FAILED)
			die("mmap: %s\n", strerror(errno));

		tokenize(buf, s.st_size);
		normalize();
	}
	dump();
}

int main(int argc, char *argv[])
{
	const char *dest;
	int fd;

	program = argv[0];
	if (argc != 3) {
		fprintf(stderr, "Usage: %s <in> <out>\n", program);
		return 1;
	}
	filename = argv[1];
	dest = argv[2];

	snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", dest);
	fd = mkstemp(tmp_file);
	if (fd < 0)
		die("creating %s: %s\n", tmp_file, strerror(errno));
	outfile = fdopen(fd, "w");
	if (!outfile)
		die("opening %s: %s\n", tmp_file, strerror(errno));

	process();
	if (rename(tmp_file, dest))
		die("renaming %s to %s: %s\n", tmp_file, dest, strerror(errno));
	return 0;
}

1	/*
2	* ttman - text to man converter
3	*
4	* Copyright 2006 Timo Hirvonen <tihirvon@gmail.com>
5	*
6	* This file is licensed under the GPLv2.
7	*/
8	#include <stdlib.h>
9	#include <stdarg.h>
10	#include <stdio.h>
11	#include <string.h>
12	#include <ctype.h>
13	#include <sys/types.h>
14	#include <sys/stat.h>
15	#include <sys/mman.h>
16	#include <unistd.h>
17	#include <fcntl.h>
18	#include <errno.h>
19
20	struct token {
21	struct token *next;
22	struct token *prev;
23	enum {
24	TOK_TEXT, // max one line w/o \n
25	TOK_NL, // \n
26	TOK_ITALIC, // `
27	TOK_BOLD, // *
28	TOK_INDENT, // \t
29
30	// keywords (@...)
31	TOK_H1,
32	TOK_H2,
33	TOK_LI,
34	TOK_BR,
35	TOK_PRE,
36	TOK_ENDPRE, // must be after TOK_PRE
37	TOK_RAW,
38	TOK_ENDRAW, // must be after TOK_RAW
39	TOK_TITLE, // WRITE 2 2001-12-13 "Linux 2.0.32" "Linux Programmer's Manual"
40	} type;
41	int line;
42
43	// not NUL-terminated
44	const char *text;
45	// length of text
46	int len;
47	};
48
49	static const char *program;
50	static const char *filename;
51	static char tmp_file[1024];
52	static FILE *outfile;
53	static int cur_line = 1;
54	static struct token head = { &head, &head, TOK_TEXT, 0, NULL, 0 };
55
56	#define CONST_STR(str) { str, sizeof(str) - 1 }
57	static const struct {
58	const char *str;
59	int len;
60	} token_names[] = {
61	CONST_STR("text"),
62	CONST_STR("nl"),
63	CONST_STR("italic"),
64	CONST_STR("bold"),
65	CONST_STR("indent"),
66
67	// keywords
68	CONST_STR("h1"),
69	CONST_STR("h2"),
70	CONST_STR("li"),
71	CONST_STR("br"),
72	CONST_STR("pre"),
73	CONST_STR("endpre"),
74	CONST_STR("raw"),
75	CONST_STR("endraw"),
76	CONST_STR("title")
77	};
78	#define NR_TOKEN_NAMES (sizeof(token_names) / sizeof(token_names[0]))
79	#define BUG() die("BUG in %s\n", __FUNCTION__)
80
81	#ifdef __GNUC__
82	#define __NORETURN __attribute__((__noreturn__))
83	#else
84	#define __NORETURN
85	#endif
86
87	static __NORETURN void quit(void)
88	{
89	if (tmp_file[0])
90	unlink(tmp_file);
91	exit(1);
92	}
93
94	static __NORETURN void die(const char *format, ...)
95	{
96	va_list ap;
97
98	fprintf(stderr, "%s: ", program);
99	va_start(ap, format);
100	vfprintf(stderr, format, ap);
101	va_end(ap);
102	quit();
103	}
104
105	static __NORETURN void syntax(int line, const char *format, ...)
106	{
107	va_list ap;
108
109	fprintf(stderr, "%s:%d: error: ", filename, line);
110	va_start(ap, format);
111	vfprintf(stderr, format, ap);
112	va_end(ap);
113	quit();
114	}
115
116	static inline const char *keyword_name(int type)
117	{
118	if (type < TOK_H1 \|\| type > TOK_TITLE)
119	die("BUG: no keyword name for type %d\n", type);
120	return token_names[type].str;
121	}
122
123	static void *xmalloc(size_t size)
124	{
125	void *ret = malloc(size);
126
127	if (!ret)
128	die("OOM when allocating %ul bytes\n", size);
129	return ret;
130	}
131
132	static char memdup(const char str, int len)
133	{
134	char *s = xmalloc(len + 1);
135	memcpy(s, str, len);
136	s[len] = 0;
137	return s;
138	}
139
140	static struct token *new_token(int type)
141	{
142	struct token *tok = xmalloc(sizeof(struct token));
143
144	tok->prev = NULL;
145	tok->next = NULL;
146	tok->type = type;
147	tok->line = cur_line;
148	return tok;
149	}
150
151	static void free_token(struct token *tok)
152	{
153	struct token *prev = tok->prev;
154	struct token *next = tok->next;
155
156	if (tok == &head)
157	BUG();
158
159	prev->next = next;
160	next->prev = prev;
161	free(tok);
162	}
163
164	static void emit_token(struct token *tok)
165	{
166	tok->prev = head.prev;
167	tok->next = &head;
168	head.prev->next = tok;
169	head.prev = tok;
170	}
171
172	static void emit(int type)
173	{
174	struct token *tok = new_token(type);
175	tok->len = 0;
176	tok->text = NULL;
177	emit_token(tok);
178	}
179
180	static int emit_keyword(const char *buf, int size)
181	{
182	int i, len;
183
184	for (len = 0; len < size; len++) {
185	if (!isalnum((unsigned char)buf[len]))
186	break;
187	}
188
189	if (!len)
190	syntax(cur_line, "keyword expected\n");
191
192	for (i = TOK_H1; i < NR_TOKEN_NAMES; i++) {
193	if (len != token_names[i].len)
194	continue;
195	if (!strncmp(buf, token_names[i].str, len)) {
196	emit(i);
197	return len;
198	}
199	}
200	syntax(cur_line, "invalid keyword '@%s'\n", memdup(buf, len));
201	}
202
203	static int emit_text(const char *buf, int size)
204	{
205	struct token *tok;
206	int i;
207
208	for (i = 0; i < size; i++) {
209	int c = buf[i];
210	if (c == '@' \|\| c == '`' \|\| c == '*' \|\| c == '\n' \|\| c == '\\' \|\| c == '\t')
211	break;
212	}
213	tok = new_token(TOK_TEXT);
214	tok->text = buf;
215	tok->len = i;
216	emit_token(tok);
217	return i;
218	}
219
220	static void tokenize(const char *buf, int size)
221	{
222	int pos = 0;
223
224	while (pos < size) {
225	struct token *tok;
226	int ch;
227
228	ch = buf[pos++];
229	switch (ch) {
230	case '@':
231	pos += emit_keyword(buf + pos, size - pos);
232	break;
233	case '`':
234	emit(TOK_ITALIC);
235	break;
236	case '*':
237	emit(TOK_BOLD);
238	break;
239	case '\n':
240	emit(TOK_NL);
241	cur_line++;
242	break;
243	case '\t':
244	emit(TOK_INDENT);
245	break;
246	case '\\':
247	tok = new_token(TOK_TEXT);
248	tok->text = buf + pos;
249	tok->len = 1;
250	pos++;
251	if (pos == size \|\| buf[pos] == '\n') {
252	// just one '\\'
253	tok->text--;
254	}
255
256	if (tok->text[0] == '\\') {
257	tok->text = "\\\\";
258	tok->len = 2;
259	}
260
261	emit_token(tok);
262	break;
263	default:
264	pos--;
265	pos += emit_text(buf + pos, size - pos);
266	break;
267	}
268	}
269	}
270
271	static int is_empty_line(const struct token *tok)
272	{
273	while (tok != &head) {
274	int i;
275
276	switch (tok->type) {
277	case TOK_TEXT:
278	for (i = 0; i < tok->len; i++) {
279	if (tok->text[i] != ' ')
280	return 0;
281	}
282	break;
283	case TOK_INDENT:
284	break;
285	case TOK_NL:
286	return 1;
287	default:
288	return 0;
289	}
290	tok = tok->next;
291	}
292	return 1;
293	}
294
295	static struct token remove_line(struct token tok)
296	{
297	while (tok != &head) {
298	struct token *next = tok->next;
299	int type = tok->type;
300
301	free_token(tok);
302	tok = next;
303	if (type == TOK_NL)
304	break;
305	}
306	return tok;
307	}
308
309	static struct token skip_after(struct token tok, int type)
310	{
311	struct token *save = tok;
312
313	while (tok != &head) {
314	if (tok->type == type) {
315	tok = tok->next;
316	if (tok->type != TOK_NL)
317	syntax(tok->line, "newline expected after @%s\n",
318	keyword_name(type));
319	return tok->next;
320	}
321	if (tok->type >= TOK_H1)
322	syntax(tok->line, "keywords not allowed betweed @%s and @%s\n",
323	keyword_name(type-1), keyword_name(type));
324	tok = tok->next;
325	}
326	syntax(save->prev->line, "missing @%s\n", keyword_name(type));
327	}
328
329	static struct token get_next_line(struct token tok)
330	{
331	while (tok != &head) {
332	int type = tok->type;
333
334	tok = tok->next;
335	if (type == TOK_NL)
336	break;
337	}
338	return tok;
339	}
340
341	static struct token get_indent(struct token tok, int *ip)
342	{
343	int i = 0;
344
345	while (tok != &head && tok->type == TOK_INDENT) {
346	tok = tok->next;
347	i++;
348	}
349	*ip = i;
350	return tok;
351	}
352
353	// line must be non-empty
354	static struct token check_line(struct token tok, int *ip)
355	{
356	struct token *start;
357	int tok_type;
358
359	start = tok = get_indent(tok, ip);
360
361	tok_type = tok->type;
362	switch (tok_type) {
363	case TOK_TEXT:
364	case TOK_BOLD:
365	case TOK_ITALIC:
366	case TOK_BR:
367	tok = tok->next;
368	while (tok != &head) {
369	switch (tok->type) {
370	case TOK_TEXT:
371	case TOK_BOLD:
372	case TOK_ITALIC:
373	case TOK_BR:
374	case TOK_INDENT:
375	break;
376	case TOK_NL:
377	return start;
378	default:
379	syntax(tok->line, "@%s not allowed inside paragraph\n",
380	keyword_name(tok->type));
381	}
382	tok = tok->next;
383	}
384	break;
385	case TOK_H1:
386	case TOK_H2:
387	case TOK_TITLE:
388	if (*ip)
389	goto indentation;
390
391	// check arguments
392	tok = tok->next;
393	while (tok != &head) {
394	switch (tok->type) {
395	case TOK_TEXT:
396	case TOK_INDENT:
397	break;
398	case TOK_NL:
399	return start;
400	default:
401	syntax(tok->line, "@%s can contain only text\n",
402	keyword_name(tok_type));
403	}
404	tok = tok->next;
405	}
406	break;
407	case TOK_LI:
408	// check arguments
409	tok = tok->next;
410	while (tok != &head) {
411	switch (tok->type) {
412	case TOK_TEXT:
413	case TOK_BOLD:
414	case TOK_ITALIC:
415	case TOK_INDENT:
416	break;
417	case TOK_NL:
418	return start;
419	default:
420	syntax(tok->line, "@%s not allowed inside @li\n",
421	keyword_name(tok->type));
422	}
423	tok = tok->next;
424	}
425	break;
426	case TOK_PRE:
427	// checked later
428	break;
429	case TOK_RAW:
430	if (*ip)
431	goto indentation;
432	// checked later
433	break;
434	case TOK_ENDPRE:
435	case TOK_ENDRAW:
436	syntax(tok->line, "@%s not expected\n", keyword_name(tok->type));
437	break;
438	case TOK_NL:
439	case TOK_INDENT:
440	BUG();
441	break;
442	}
443	return start;
444	indentation:
445	syntax(tok->line, "indentation before @%s\n", keyword_name(tok->type));
446	}
447
448	static void insert_nl_before(struct token *next)
449	{
450	struct token *prev = next->prev;
451	struct token *new = new_token(TOK_NL);
452
453	new->prev = prev;
454	new->next = next;
455	prev->next = new;
456	next->prev = new;
457	}
458
459	static void normalize(void)
460	{
461	struct token *tok = head.next;
462	/*
463	* >= 0 if previous line was text (== amount of indent)
464	* -1 if previous block was @pre (amount of indent doesn't matter)
465	* -2 otherwise (@h1 etc., indent was 0)
466	*/
467	int prev_indent = -2;
468
469	while (tok != &head) {
470	struct token *start;
471	int i, new_para = 0;
472
473	// remove empty lines
474	while (is_empty_line(tok)) {
475	tok = remove_line(tok);
476	new_para = 1;
477	if (tok == &head)
478	return;
479	}
480
481	// skips indent
482	start = tok;
483	tok = check_line(tok, &i);
484
485	switch (tok->type) {
486	case TOK_TEXT:
487	case TOK_ITALIC:
488	case TOK_BOLD:
489	case TOK_BR:
490	// normal text
491	if (new_para && prev_indent >= -1) {
492	// previous line/block was text or @pre
493	// and there was a empty line after it
494	insert_nl_before(start);
495	}
496
497	if (!new_para && prev_indent == i) {
498	// join with previous line
499	struct token *nl = start->prev;
500
501	if (nl->type != TOK_NL)
502	BUG();
503
504	if ((nl->prev != &head && nl->prev->type == TOK_BR) \|\|
505	tok->type == TOK_BR) {
506	// don't convert \n after/before @br to ' '
507	free_token(nl);
508	} else {
509	// convert "\n" to " "
510	nl->type = TOK_TEXT;
511	nl->text = " ";
512	nl->len = 1;
513	}
514
515	// remove indent
516	while (start->type == TOK_INDENT) {
517	struct token *next = start->next;
518	free_token(start);
519	start = next;
520	}
521	}
522
523	prev_indent = i;
524	tok = get_next_line(tok);
525	break;
526	case TOK_PRE:
527	case TOK_RAW:
528	// these can be directly after normal text
529	// but not joined with the previous line
530	if (new_para && prev_indent >= -1) {
531	// previous line/block was text or @pre
532	// and there was a empty line after it
533	insert_nl_before(start);
534	}
535	tok = skip_after(tok->next, tok->type + 1);
536	prev_indent = -1;
537	break;
538	case TOK_H1:
539	case TOK_H2:
540	case TOK_LI:
541	case TOK_TITLE:
542	// remove white space after H1, H2, L1 and TITLE
543	tok = tok->next;
544	while (tok != &head) {
545	int type = tok->type;
546	struct token *next;
547
548	if (type == TOK_TEXT) {
549	while (tok->len && *tok->text == ' ') {
550	tok->text++;
551	tok->len--;
552	}
553	if (tok->len)
554	break;
555	}
556	if (type != TOK_INDENT)
557	break;
558
559	// empty TOK_TEXT or TOK_INDENT
560	next = tok->next;
561	free_token(tok);
562	tok = next;
563	}
564	// not normal text. can't be joined
565	prev_indent = -2;
566	tok = get_next_line(tok);
567	break;
568	case TOK_NL:
569	case TOK_INDENT:
570	case TOK_ENDPRE:
571	case TOK_ENDRAW:
572	BUG();
573	break;
574	}
575	}
576	}
577
578	#define output(...) fprintf(outfile, __VA_ARGS__)
579
580	static void output_buf(const char *buf, int len)
581	{
582	fwrite(buf, 1, len, outfile);
583	}
584
585	static void output_text(struct token *tok)
586	{
587	char buf[1024];
588	const char *str = tok->text;
589	int len = tok->len;
590	int pos = 0;
591
592	while (len) {
593	int c = *str++;
594
595	if (pos >= sizeof(buf) - 1) {
596	output_buf(buf, pos);
597	pos = 0;
598	}
599	if (c == '-')
600	buf[pos++] = '\\';
601	buf[pos++] = c;
602	len--;
603	}
604
605	if (pos)
606	output_buf(buf, pos);
607	}
608
609	static int bold = 0;
610	static int italic = 0;
611	static int indent = 0;
612
613	static struct token output_pre(struct token tok)
614	{
615	int bol = 1;
616
617	if (tok->type != TOK_NL)
618	syntax(tok->line, "newline expected after @pre\n");
619
620	output(".nf\n");
621	tok = tok->next;
622	while (tok != &head) {
623	if (bol) {
624	int i;
625
626	tok = get_indent(tok, &i);
627	if (i != indent && tok->type != TOK_NL)
628	syntax(tok->line, "indent changed in @pre\n");
629	}
630
631	switch (tok->type) {
632	case TOK_TEXT:
633	if (bol && tok->len && tok->text[0] == '.')
634	output("\\&");
635	output_text(tok);
636	break;
637	case TOK_NL:
638	output("\n");
639	bol = 1;
640	tok = tok->next;
641	continue;
642	case TOK_ITALIC:
643	output("`");
644	break;
645	case TOK_BOLD:
646	output("*");
647	break;
648	case TOK_INDENT:
649	// FIXME: warn
650	output(" ");
651	break;
652	case TOK_ENDPRE:
653	output(".fi\n");
654	tok = tok->next;
655	if (tok != &head && tok->type == TOK_NL)
656	tok = tok->next;
657	return tok;
658	default:
659	BUG();
660	break;
661	}
662	bol = 0;
663	tok = tok->next;
664	}
665	return tok;
666	}
667
668	static struct token output_raw(struct token tok)
669	{
670	if (tok->type != TOK_NL)
671	syntax(tok->line, "newline expected after @raw\n");
672
673	tok = tok->next;
674	while (tok != &head) {
675	switch (tok->type) {
676	case TOK_TEXT:
677	if (tok->len == 2 && !strncmp(tok->text, "\\\\", 2)) {
678	/* ugly special case
679	* "\\" (\) was converted to "\\\\" (\\) because
680	* nroff does escaping too.
681	*/
682	output("\\");
683	} else {
684	output_buf(tok->text, tok->len);
685	}
686	break;
687	case TOK_NL:
688	output("\n");
689	break;
690	case TOK_ITALIC:
691	output("`");
692	break;
693	case TOK_BOLD:
694	output("*");
695	break;
696	case TOK_INDENT:
697	output("\t");
698	break;
699	case TOK_ENDRAW:
700	tok = tok->next;
701	if (tok != &head && tok->type == TOK_NL)
702	tok = tok->next;
703	return tok;
704	default:
705	BUG();
706	break;
707	}
708	tok = tok->next;
709	}
710	return tok;
711	}
712
713	static struct token output_para(struct token tok)
714	{
715	int bol = 1;
716
717	while (tok != &head) {
718	switch (tok->type) {
719	case TOK_TEXT:
720	output_text(tok);
721	break;
722	case TOK_ITALIC:
723	italic ^= 1;
724	if (italic) {
725	output("\\fI");
726	} else {
727	output("\\fR");
728	}
729	break;
730	case TOK_BOLD:
731	bold ^= 1;
732	if (bold) {
733	output("\\fB");
734	} else {
735	output("\\fR");
736	}
737	break;
738	case TOK_BR:
739	if (bol) {
740	output(".br\n");
741	} else {
742	output("\n.br\n");
743	}
744	bol = 1;
745	tok = tok->next;
746	continue;
747	case TOK_NL:
748	output("\n");
749	return tok->next;
750	case TOK_INDENT:
751	output(" ");
752	break;
753	default:
754	BUG();
755	break;
756	}
757	bol = 0;
758	tok = tok->next;
759	}
760	return tok;
761	}
762
763	static struct token title(struct token tok, const char *cmd)
764	{
765	output("%s", cmd);
766	return output_para(tok->next);
767	}
768
769	static struct token dump_one(struct token tok)
770	{
771	int i;
772
773	tok = get_indent(tok, &i);
774	if (tok->type != TOK_RAW) {
775	while (indent < i) {
776	output(".RS\n");
777	indent++;
778	}
779	while (indent > i) {
780	output(".RE\n");
781	indent--;
782	}
783	}
784
785	switch (tok->type) {
786	case TOK_TEXT:
787	case TOK_ITALIC:
788	case TOK_BOLD:
789	case TOK_BR:
790	if (tok->type == TOK_TEXT && tok->len && tok->text[0] == '.')
791	output("\\&");
792	tok = output_para(tok);
793	break;
794	case TOK_H1:
795	tok = title(tok, ".SH ");
796	break;
797	case TOK_H2:
798	tok = title(tok, ".SS ");
799	break;
800	case TOK_LI:
801	tok = title(tok, ".TP\n");
802	break;
803	case TOK_PRE:
804	tok = output_pre(tok->next);
805	break;
806	case TOK_RAW:
807	tok = output_raw(tok->next);
808	break;
809	case TOK_TITLE:
810	tok = title(tok, ".TH ");
811	// must be after .TH
812	// no hyphenation, adjust left
813	output(".nh\n.ad l\n");
814	break;
815	case TOK_NL:
816	output("\n");
817	tok = tok->next;
818	break;
819	case TOK_ENDPRE:
820	case TOK_ENDRAW:
821	case TOK_INDENT:
822	BUG();
823	break;
824	}
825	return tok;
826	}
827
828	static void dump(void)
829	{
830	struct token *tok = head.next;
831
832	while (tok != &head)
833	tok = dump_one(tok);
834	}
835
836	static void process(void)
837	{
838	struct stat s;
839	const char *buf;
840	int fd;
841
842	fd = open(filename, O_RDONLY);
843	if (fd == -1)
844	die("opening `%s' for reading: %s\n", filename, strerror(errno));
845	fstat(fd, &s);
846	if (s.st_size) {
847	buf = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
848	if (buf == MAP_FAILED)
849	die("mmap: %s\n", strerror(errno));
850
851	tokenize(buf, s.st_size);
852	normalize();
853	}
854	dump();
855	}
856
857	int main(int argc, char *argv[])
858	{
859	const char *dest;
860	int fd;
861
862	program = argv[0];
863	if (argc != 3) {
864	fprintf(stderr, "Usage: %s <in> <out>\n", program);
865	return 1;
866	}
867	filename = argv[1];
868	dest = argv[2];
869
870	snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", dest);
871	fd = mkstemp(tmp_file);
872	if (fd < 0)
873	die("creating %s: %s\n", tmp_file, strerror(errno));
874	outfile = fdopen(fd, "w");
875	if (!outfile)
876	die("opening %s: %s\n", tmp_file, strerror(errno));
877
878	process();
879	if (rename(tmp_file, dest))
880	die("renaming %s to %s: %s\n", tmp_file, dest, strerror(errno));
881	return 0;
882	}

Gitorious