tmpl

tmpl.c (5242B)

#define _XOPEN_SOURCE 500

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>

enum {
	IFEQ,
	IFDEF,
	ELSE
};

struct block {
	int active;
	int type;
};

struct var {
	const char *name;
	const char *value;
	struct var *next;
};

static struct var *vars = NULL;
static struct var **vars_end = &vars;

static struct block stack[32] = { 0 };
static int stack_top = 0;
static size_t lineno = 0;

static bool fail_missing = false;

static const char *prefix = "#{";

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

	va_start(ap, fmt);
	fputs("tmpl: ", stderr);
	vfprintf(stderr, fmt, ap);
	if (*fmt && fmt[strlen(fmt)-1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
	va_end(ap);

	exit(1);
}

static const char *
getvar(const char *name)
{
	const char *env;
	struct var *var;

	for (var = vars; var; var = var->next) {
		if (!strcmp(var->name, name))
			return var->value;
	}

	env = getenv(name);
	if (!env && fail_missing)
		die("not set: '%s'", name);

	return env;
}

static void
assign(char *line)
{
	char *sep;
	struct var *var;

	sep = strchr(line, '=');
	if (!sep) die("invalid assign '%s'", line);

	line = strdup(line);
	if (!line) die("strdup:");
	sep = strchr(line, '=');
	*sep = '\0';

	var = malloc(sizeof(struct var));
	if (!var) die("malloc:");
	var->name = line;
	var->value = sep + 1;
	var->next = NULL;

	*vars_end = var;
	vars_end = &var->next;
}

static void
template(char *line)
{
	const char *value;
	char *open, *close;
	char *sep;

	lineno++;

	if (!strncmp(line, "#ifdef ", 7)) {
		if (stack_top == 32) die("too deeply nested");
		stack[stack_top].active = 0;
		stack[stack_top].type = IFDEF;
		if (!stack_top || stack[stack_top-1].active) {
			if (getvar(line + 7))
				stack[stack_top].active = 1;
		}
		stack_top++;
	} else if (!strncmp(line, "#ifeq ", 6)) {
		if (stack_top == 32) die("too deeply nested");
		stack[stack_top].active = 0;
		stack[stack_top].type = IFEQ;
		if (!stack_top || stack[stack_top-1].active) {
			sep = strchr(line + 6, ' ');
			if (!sep) die("invalid #ifeq\n%lu: %s", lineno, line);
			*sep = '\0';
			value = getvar(line + 6);
			if (value && !strcmp(value, sep + 1))
				stack[stack_top].active = 1;
		}
		stack_top++;
	} else if (!strcmp(line, "#else")) {
		if (!stack_top || (stack[stack_top-1].type != IFDEF
				&& stack[stack_top-1].type != IFEQ))
			die("invalid #else\n%lu: %s", lineno, line);
		stack[stack_top-1].active ^= 1;
		stack[stack_top-1].type = ELSE;
	} else if (!strcmp(line, "#endif")) {
		if (!stack_top) die("invalid #endif\n%lu: %s", lineno, line);
		stack_top--;
	} else if (!strncmp(line, "#define ", 8)) {
		if (stack_top && !stack[stack_top-1].active)
			return;

		sep = strchr(line + 8, ' ');
		if (!sep) die("invalid #default\n%lu: %s", lineno, line);
		*sep = '=';
		assign(line + 8);
	} else if (!strncmp(line, "#default ", 9)) {
		if (stack_top && !stack[stack_top-1].active)
			return;

		sep = strchr(line + 9, ' ');
		if (!sep) die("invalid #default\n%lu: %s", lineno, line);
		*sep = '\0';
		value = getvar(line + 9);
		if (!value) {
			*sep = '=';
			assign(line + 9);
		}
	} else if (!strncmp(line, "\\#", 2)) {
		puts(line+1); /* escaped */
	} else if (!strncmp(line, "#-- ", 4)) {
		return; /* comment */
	} else {
		if (stack_top && !stack[stack_top-1].active)
			return;

		while (1) {
			open = strstr(line, prefix);
			if (!open) break;

			if (open != line && open[-1] == '\\') {
				open[-1] = '\0';
				fputs(line, stdout);
				fputs(prefix, stdout);
				line = open + 2;
				continue;
			}

			close = strchr(open, '}');
			if (!close) break;

			*open = '\0';
			fputs(line, stdout);

			*close = '\0';
			value = getvar(open + 2);
			if (value) fputs(value, stdout);

			line = close + 1;
		}

		puts(line);
	}
}

static void
perline(const char *path, int nonempty, void (*process)(char *))
{
	char linebuf[4096];
	size_t len;
	FILE *f;

	f = fopen(path, "r");
	if (!f) die("fopen '%s':", path);
	while (fgets(linebuf, 4096, f)) {
		len = strlen(linebuf);
		if (len && linebuf[len - 1] == '\n') {
			linebuf[--len] = '\0';
		} else if (len && !feof(f)) {
			die("fgets '%s': line too long", path);
		}
		if (len || !nonempty)
			process(linebuf);
	}
	fclose(f);
}

int
main(int argc, char **argv)
{
	const char *path;
	char **arg, **dst;

	if (!argc) return 1;

	for (dst = arg = argv + 1; *arg; arg++) {
		if (!strcmp(*arg, "-e")) {
			fail_missing = true;
		} else if (!strcmp(*arg, "-p")) {
			prefix = *++arg;
			if (!prefix || !*prefix) die("invalid prefix");
		} else {
			*dst++ = *arg;
		}
	}
	*dst = NULL;

	for (arg = argv + 1; *arg; arg++) {
		if (!strcmp(*arg, "-h") || !strcmp(*arg, "--help")) {
			fprintf(stderr, "Usage: tmpl [-e] [-c CONFIG].. "
				"[-D NAME=VALUE].. FILE..\n");
			return 1;
		} else if (!strcmp(*arg, "-D") || !strcmp(*arg, "--define")) {
			if (!*++arg) die("missing argument");
			assign(*arg);
		} else if (!strcmp(*arg, "-c") || !strcmp(*arg, "--config")) {
			if (!*++arg) die("missing argument");
			perline(*arg, 1, assign);
		} else {
			break;
		}
	}

	for (; *arg; arg++) {
		path = !strcmp(*arg, "-") ? "/dev/stdin" : *arg;
		perline(path, 0, template);
	}
}