/*
 * fref creates troff-formatted references according to specifications
 * given on standard in. The specification syntax is similar to that of
 * refer, but differs in that all identifiers are two letters instead of
 * one (like troff itself). This allows for a larger number of fields.
 *
 * To build fref, run the following commands:
 *    $ lex fref.lex
 *    $ cc -std=c89 -O2 -o fref lex.yy.c -lfl
 */

%x ENTRY

	#include <err.h>
	#include <stdarg.h>

	#define MAX 255 /* Max field length. */

	#define FOR_FIELDS						\
		DO("ad",ad,e.ad) /* Access date. */			\
		DO("bo",bo,e.bo) /* Book. */				\
		DO("ci",ci,e.ci) /* City. */				\
		DO("da",da,e.da) /* Date (year). */			\
		DO("ed",ed,e.ed) /* Editor. */				\
		DO("hr",hr,e.hr) /* Hypertext reference. */		\
		DO("jo",jo,e.jo) /* Journal. */				\
		DO("la",la,e.la) /* Label. */				\
		DO("lg",lg,e.lg) /* Reference-specific language. */	\
		DO("no",no,e.no) /* TODO: Issue number. */		\
		DO("pp",pp,e.pp) /* Pages. */				\
		DO("pu",pu,e.pu) /* Publisher. */			\
		DO("se",se,e.se) /* TODO: Series. */			\
		DO("ti",ti,e.ti) /* Title. */				\
		DO("tr",tr,e.tr) /* Translator. */			\
		DO("vo",vo,e.vo) /* Volume. */				\
		DO("xx",xx,e.xx) /* Extra information. */		\
	/* END */

	void entry(void);
	void field(char *);
	void harvard(void);
	struct trans *gettrans(char *);
	int pf(char *, ...);

	/* Fields of current entry. */
	struct entry {
		int a;			/* Number of authors. */
		char au[MAX][MAX];	/* Authors. */
		#define DO(s,n,m) char n[MAX];
		FOR_FIELDS
		#undef DO
	} e;

	/* Translation strings. */
	struct trans {
		char *and;
		char *avail;
		char *ed;
		char *p;
		char *pp;
		char *tr;
		char *vo;
	};

	extern char *optarg;
	extern int optind;

	char *name;			/* Program name. */
	char *lang = NULL;		/* Main language (-l). */
	int line;			/* Line at which entry begins. */
	int lines = 0;			/* Total number of lines. */
	struct trans *len = NULL;	/* English strings. */
	struct trans *lru = NULL;	/* Russian strings. */
	struct trans *lsv = NULL;	/* Swedish strings. */

%%
\n		lines++;	ECHO;
^%.*\n		line = ++lines;	field(yytext); BEGIN(ENTRY);
<ENTRY>^%.*\n	lines++;	field(yytext);
<ENTRY>^[^%]			entry(); ECHO; BEGIN(0);
<ENTRY><<EOF>>			entry(); yyterminate();
%%

void
main(int argc, char *argv[])
{
	int c;

	/* Save program name. */
	name = strrchr(argv[0], '/');
	if(name) name++;
	else name = argv[0];

	/* Parse command-line options. */
	while((c = getopt(argc, argv, "l:")) != -1)
		switch(c){
		case 'l':
			lang = optarg;
			break;
		default:
			fprintf(stderr, "usage: %s [-lLANG]\n", argv[0]);
			exit(1);
		}
	argc -= optind;
	argv += optind;

	if(!lang)
		lang = strdup("en");
	gettrans(lang);

	/* Clear entry struct. */
	memset(&e, 0, sizeof(e));

	yylex();
}

/* Save entry field. */
void
field(char *s)
{
	s++;
	s[strcspn(s, "\n")] = 0;

	/* Fill corresponding field. */
	#define AS(a,b) \
		if(strncmp(s, a, 2) == 0 && (s += 3)){ strcpy(b, s); return; }

	AS("au",e.au[e.a++]);
	#define DO(s,n,m) AS(s,m)
	FOR_FIELDS
	#undef DO

	/*
	 * As no field matched, an error is printed and the program exits
	 * with a positive value.
	 */
	fprintf(stderr, "%s: unrecognized field %%%.2s at line %d\n",
		name, s, lines);
	exit(1);
}

/* Print formatted entry. */
void
entry()
{
	/*
	   Presently, fref supports only Harvard-style citations, but
	   this allows for future extensions.
	 */
	harvard();
}

/* Print Harvard-formatted entry. */
void
harvard()
{
	struct trans *t;
	int i;

	/* Get translation strings. */
	t = gettrans(*e.lg ? e.lg : lang);
	*e.lg = 0;

	/* Print label. */
	pf("% = ", e.la);

	/* Print authors. */
	for(i = 0; i < e.a-2; i++)
		pf("*, ", e.au[i]);
	if(i == e.a-2)
		pf("* * ", e.au[i++], t->and);
	if(i == e.a-1)
		pf("*", e.au[i]);

	/* Print date. */
	if(!pf(" (%).\n", e.da) && e.a){
		if(e.au[i][strlen(e.au[i])-1] != '.')
			pf(".");
		pf("\n");
	}

	/* Print title, book/journal. */
	if(*e.bo || *e.jo){
		pf("%.\n", e.ti);
		pf("\\fI%\\fP", e.bo ? e.bo : e.jo);
		pf(" (*%)", t->ed, e.ed);
	}else
		pf("\\fI%\\fP", e.ti);

	/* Print volume. */
	pf(", *%", t->vo, e.vo);

	/* Print pages, converting hyphens to en dashes. */
	if(*e.pp){
		pf(", *", strpbrk(e.pp, ",-") ? t->pp : t->p);
		for(i = 0; i < strlen(e.pp); i++){
			if(e.pp[i] == '-') putchar('\\');
			putchar(e.pp[i]);
		}
		*e.pp = 0;
	}
	pf(".\n");

	/* Print translator. */
	pf("*%.\n", t->tr, e.tr);

	/* Print city, publisher. */
	(pf("%: %.\n", e.ci, e.pu) || pf("%.\n", e.pu));

	/* Print other information. */
	pf("%.\n", e.xx);

	/* Print hypertext reference. */
	pf("*%\n", t->avail, e.hr);

	/* Print access date. */
	pf("[%]\n", e.ad);

	/* Reset state. */
	e.a = 0;
	#define DO(s,n,m) if(*m){					\
		fprintf(stderr, "%s: unused field %%" s			\
			" in reference at line %d\n",			\
			name, line);					\
		*m = 0;							\
	}
	FOR_FIELDS
	#undef DO
}

/* Return pointer to translation struct. */
struct trans *
gettrans(char *lg)
{
	if(strncmp(lg, "en", 2) == 0){
		if(!len){
			if(!(len = malloc(sizeof(struct trans))))
				err(1, "malloc");
			len->and = strdup("and");
			len->avail = strdup("Available: ");
			len->ed = strdup("ed. ");
			len->p = strdup("p. ");
			len->pp = strdup("pp. ");
			len->tr = strdup("Trans. ");
			len->vo = strdup("vol. ");
		}
		return len;
	}else if(strncmp(lg, "ru", 2) == 0){
		if(!lru){
			if(!(lru = malloc(sizeof(struct trans))))
				err(1, "malloc");
			lru->and = strdup("и");
			lru->avail = strdup("Доступный: ");
			lru->ed = strdup("ред. ");
			lru->p = strdup("c. ");
			lru->pp = strdup("с. ");
			lru->tr = strdup("Перев. ");
			lru->vo = strdup("том ");
		}
		return lru;
	}else if(strncmp(lg, "sv", 2) == 0){
		if(!lsv){
			if(!(lsv = malloc(sizeof(struct trans))))
				err(1, "malloc");
			lsv->and = strdup("och");
			lsv->avail = strdup("Tillgänglig: ");
			lsv->ed = strdup("red. ");
			lsv->p = strdup("s. ");
			lsv->pp = strdup("ss. ");
			lsv->tr = strdup("Övers. ");
			lsv->vo = strdup("vol. ");
		}
		return lsv;
	}else{
		fprintf(stderr, "%s: unrecognized language %s"
			" in reference at line %d\n",
			name, lg, line);
		exit(1);
	}
}

/*
 * This function interpolates any number of strings into a formatted
 * string, which is printed only if all interpolated strings are non-empty.
 * Interpolation points are marked by % or *. If a string is interpolated
 * using %, the function empties it after printing it.
 */
int
pf(char *fmt, ...)
{
	char *buf, *p, **fs;
	int i, n, sz;
	va_list ap;

	/* Count interpolated strings. */
	for(n = 0, p = fmt; *p; p++)
		if(*p == '%' || *p == '*')
			n++;

	if(!(fs = malloc(n)))
		err(1, "malloc");

	/*
	 * The strings to be interpolated are saved in fs.
	 * If any string is empty, the function returns false.
	 */
	va_start(ap, fmt);
	for(i = 0; i < n; i++){
		p = va_arg(ap, char *);
		if(!p || !*p)
			return 0;
		fs[i] = p;
	}
	va_end(ap);

	/* Print formatted string. */
	for(i = 0; *fmt; fmt++)
		switch(*fmt){
		case '%':
			printf("%s", fs[i]);
			fs[i][0] = 0;
			i++;
			break;
		case '*':
			printf("%s", fs[i]);
			i++;
			break;
		default:
			putchar(*fmt);
		}
	return 1;
}