[sgt/halibut] / main.c

/*
 * main.c: command line parsing and top level
 */

#include <assert.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include "halibut.h"

static void dbg_prtsource(paragraph *sourceform);
static void dbg_prtwordlist(int level, word *w);
static void dbg_prtkws(keywordlist *kws);

static const struct pre_backend {
    void *(*func)(paragraph *, keywordlist *, indexdata *);
    int bitfield;
} pre_backends[] = {
    {paper_pre_backend, 0x0001}
};

static const struct backend {
    char *name;
    void (*func)(paragraph *, keywordlist *, indexdata *, void *);
    paragraph *(*filename)(char *filename);
    int bitfield, prebackend_bitfield;
} backends[] = {
    {"text", text_backend, text_config_filename, 0x0001, 0},
    {"xhtml", html_backend, html_config_filename, 0x0002, 0},
    {"html", html_backend, html_config_filename, 0x0002, 0},
    {"hlp", whlp_backend, whlp_config_filename, 0x0004, 0},
    {"whlp", whlp_backend, whlp_config_filename, 0x0004, 0},
    {"winhelp", whlp_backend, whlp_config_filename, 0x0004, 0},
    {"man", man_backend, man_config_filename, 0x0008, 0},
    {"info", info_backend, info_config_filename, 0x0010, 0},
    {"ps", ps_backend, ps_config_filename, 0x0020, 0x0001},
    {"pdf", pdf_backend, pdf_config_filename, 0x0040, 0x0001},
};

int main(int argc, char **argv) {
    char **infiles;
    int nfiles;
    int nogo;
    int errs;
    int reportcols;
    int list_fonts;
    int input_charset;
    int debug;
    int backendbits, prebackbits;
    int k, b;
    paragraph *cfg, *cfg_tail;
    void *pre_backend_data[16];

    /*
     * Use the specified locale everywhere. It'll be used for
     * output of error messages, and as the default character set
     * for input files if one is not explicitly specified.
     * 
     * However, we need to use standard numeric formatting for
     * output of things like PDF.
     */
    setlocale(LC_ALL, "");
    setlocale(LC_NUMERIC, "C");

    /*
     * Set up initial (default) parameters.
     */
    infiles = snewn(argc, char *);
    nfiles = 0;
    nogo = errs = FALSE;
    reportcols = 0;
    list_fonts = 0;
    input_charset = CS_ASCII;
    debug = 0;
    backendbits = 0;
    cfg = cfg_tail = NULL;

    if (argc == 1) {
	usage();
	exit(EXIT_SUCCESS);
    }

    /*
     * Parse command line arguments.
     */
    while (--argc) {
	char *p = *++argv;
	if (*p == '-' && p[1]) {
	    /*
	     * An option.
	     */
	    while (p && *++p) {
		char c = *p;
		switch (c) {
		  case '-':
		    /*
		     * Long option.
		     */
		    {
			char *opt, *val;
			opt = p++;     /* opt will have _one_ leading - */
			while (*p && *p != '=')
			    p++;	       /* find end of option */
			if (*p == '=') {
			    *p++ = '\0';
			    val = p;
			} else
			    val = NULL;

			assert(opt[0] == '-');
			for (k = 0; k < (int)lenof(backends); k++)
			    if (!strcmp(opt+1, backends[k].name)) {
				backendbits |= backends[k].bitfield;
				if (val) {
				    paragraph *p = backends[k].filename(val);
				    assert(p);
				    if (cfg_tail)
					cfg_tail->next = p;
				    else
					cfg = p;
				    while (p->next)
					p = p->next;
				    cfg_tail = p;
				}
				break;
			    }
			if (k < (int)lenof(backends)) {
			    /* do nothing */;
			} else if (!strcmp(opt, "-input-charset")) {
			    if (!val) {
				errs = TRUE, error(err_optnoarg, opt);
			    } else {
				int charset = charset_from_localenc(val);
				if (charset == CS_NONE) {
				    errs = TRUE, error(err_cmdcharset, val);
				} else {
				    input_charset = charset;
				}
			    }
			} else if (!strcmp(opt, "-help")) {
			    help();
			    nogo = TRUE;
			} else if (!strcmp(opt, "-version")) {
			    showversion();
			    nogo = TRUE;
			} else if (!strcmp(opt, "-licence") ||
				   !strcmp(opt, "-license")) {
			    licence();
			    nogo = TRUE;
			} else if (!strcmp(opt, "-list-charsets")) {
			    listcharsets();
			    nogo = TRUE;
			} else if (!strcmp(opt, "-list-fonts")) {
			    list_fonts = TRUE;
			} else if (!strcmp(opt, "-precise")) {
			    reportcols = 1;
			} else {
			    errs = TRUE, error(err_nosuchopt, opt);
			}
		    }
		    p = NULL;
		    break;
		  case 'h':
		  case 'V':
		  case 'L':
		  case 'P':
		  case 'd':
		    /*
		     * Option requiring no parameter.
		     */
		    switch (c) {
		      case 'h':
			help();
			nogo = TRUE;
			break;
		      case 'V':
			showversion();
			nogo = TRUE;
			break;
		      case 'L':
			licence();
			nogo = TRUE;
			break;
		      case 'P':
			reportcols = 1;
			break;
		      case 'd':
			debug = TRUE;
			break;
		    }
		    break;
		  case 'C':
		    /*
		     * Option requiring parameter.
		     */
		    p++;
		    if (!*p && argc > 1)
			--argc, p = *++argv;
		    else if (!*p) {
			char opt[2];
			opt[0] = c;
			opt[1] = '\0';
			errs = TRUE, error(err_optnoarg, opt);
		    }
		    /*
		     * Now c is the option and p is the parameter.
		     */
		    switch (c) {
		      case 'C':
			/*
			 * -C means we split our argument up into
			 * colon-separated chunks and assemble them
			 * into a config paragraph.
			 */
			{
			    char *s = dupstr(p), *q, *r;
			    paragraph *para;

			    para = cmdline_cfg_new();

			    q = r = s;
			    while (*q) {
				if (*q == ':') {
				    *r = '\0';
				    /* XXX ad-hoc diagnostic */
				    if (!strcmp(s, "input-charset"))
					error(err_futileopt, "Cinput-charset",
					      "; use --input-charset");
				    cmdline_cfg_add(para, s);
				    r = s;
				} else {
				    if (*q == '\\' && q[1])
					q++;
				    *r++ = *q;
				}
				q++;
			    }
			    *r = '\0';
			    cmdline_cfg_add(para, s);

			    if (cfg_tail)
				cfg_tail->next = para;
			    else
				cfg = para;
			    cfg_tail = para;
			}
			break;
		    }
		    p = NULL;	       /* prevent continued processing */
		    break;
		  default:
		    /*
		     * Unrecognised option.
		     */
		    {
			char opt[2];
			opt[0] = c;
			opt[1] = '\0';
			errs = TRUE, error(err_nosuchopt, opt);
		    }
		}
	    }
	} else {
	    /*
	     * A non-option argument.
	     */
	    if (!strcmp(p, "-"))
		infiles[nfiles++] = NULL;   /* special case: read stdin */
	    else
		infiles[nfiles++] = p;
	}
    }

    if (errs)
	exit(EXIT_FAILURE);
    if (nogo)
	exit(EXIT_SUCCESS);

    /*
     * Do the work.
     */
    if (nfiles == 0 && !list_fonts) {
	error(err_noinput);
	usage();
	exit(EXIT_FAILURE);
    }

    {
	input in;
	paragraph *sourceform, *p;
	indexdata *idx;
	keywordlist *keywords;

	in.filenames = infiles;
	in.nfiles = nfiles;
	in.currfp = NULL;
	in.currindex = 0;
	in.npushback = in.pushbacksize = 0;
	in.pushback = NULL;
	in.reportcols = reportcols;
	in.stack = NULL;
	in.defcharset = input_charset;

	idx = make_index();

	sourceform = read_input(&in, idx);
	if (list_fonts) {
	    listfonts();
	    exit(EXIT_SUCCESS);
	}
	if (!sourceform)
	    exit(EXIT_FAILURE);

	/*
	 * Append the config directives acquired from the command
	 * line.
	 */
	{
	    paragraph *end;

	    end = sourceform;
	    while (end && end->next)
		end = end->next;
	    assert(end);

	    end->next = cfg;
	}

	sfree(in.pushback);

	sfree(infiles);

	keywords = get_keywords(sourceform);
	if (!keywords)
	    exit(EXIT_FAILURE);
	gen_citations(sourceform, keywords);
	subst_keywords(sourceform, keywords);

	for (p = sourceform; p; p = p->next)
	    if (p->type == para_IM)
		index_merge(idx, TRUE, p->keyword, p->words, &p->fpos);

	build_index(idx);

	/*
	 * Set up attr_First / attr_Last / attr_Always, in the main
	 * document and in the index entries.
	 */
	for (p = sourceform; p; p = p->next)
	    mark_attr_ends(p->words);
	{
	    int i;
	    indexentry *entry;

	    for (i = 0; (entry = index234(idx->entries, i)) != NULL; i++)
		mark_attr_ends(entry->text);
	}

	if (debug) {
	    index_debug(idx);
	    dbg_prtkws(keywords);
	    dbg_prtsource(sourceform);
	}

	/*
	 * Select and run the pre-backends.
	 */
	prebackbits = 0;
	for (k = 0; k < (int)lenof(backends); k++)
	    if (backendbits == 0 || (backendbits & backends[k].bitfield))
		prebackbits |= backends[k].prebackend_bitfield;
	for (k = 0; k < (int)lenof(pre_backends); k++)
	    if (prebackbits & pre_backends[k].bitfield) {
		assert(k < (int)lenof(pre_backend_data));
		pre_backend_data[k] =
		    pre_backends[k].func(sourceform, keywords, idx);
	    }

	/*
	 * Run the selected set of backends.
	 */
	for (k = b = 0; k < (int)lenof(backends); k++)
	    if (b != backends[k].bitfield) {
		b = backends[k].bitfield;
		if (backendbits == 0 || (backendbits & b)) {
		    void *pbd = NULL;
		    int pbb = backends[k].prebackend_bitfield;
		    int m;

		    for (m = 0; m < (int)lenof(pre_backends); m++)
			if (pbb & pre_backends[m].bitfield) {
			    assert(m < (int)lenof(pre_backend_data));
			    pbd = pre_backend_data[m];
			    break;
			}
			    
		    backends[k].func(sourceform, keywords, idx, pbd);
		}
	    }

	free_para_list(sourceform);
	free_keywords(keywords);
	cleanup_index(idx);
    }

    return 0;
}

static void dbg_prtsource(paragraph *sourceform) {
    /*
     * Output source form in debugging format.
     */

    paragraph *p;
    for (p = sourceform; p; p = p->next) {
	wchar_t *wp;
	printf("para %d ", p->type);
	if (p->keyword) {
	    wp = p->keyword;
	    while (*wp) {
		putchar('\"');
		for (; *wp; wp++)
		    putchar(*wp);
		putchar('\"');
		if (*++wp)
		    printf(", ");
	    }
	} else
	    printf("(no keyword)");
	printf(" {\n");
	dbg_prtwordlist(1, p->words);
	printf("}\n");
    }
}

static void dbg_prtkws(keywordlist *kws) {
    /*
     * Output keywords in debugging format.
     */

    int i;
    keyword *kw;

    for (i = 0; (kw = index234(kws->keys, i)) != NULL; i++) {
	wchar_t *wp;
	printf("keyword ");
	wp = kw->key;
	while (*wp) {
	    putchar('\"');
	    for (; *wp; wp++)
		putchar(*wp);
	    putchar('\"');
	    if (*++wp)
		printf(", ");
	}
	printf(" {\n");
	dbg_prtwordlist(1, kw->text);
	printf("}\n");
    }
}

static void dbg_prtwordlist(int level, word *w) {
    for (; w; w = w->next) {
	wchar_t *wp;
	printf("%*sword %d ", level*4, "", w->type);
	if (w->text) {
	    printf("\"");
	    for (wp = w->text; *wp; wp++)
		    putchar(*wp);
	    printf("\"");
	} else
	    printf("(no text)");
	if (w->breaks)
	    printf(" [breaks]");
	if (w->alt) {
	    printf(" alt = {\n");
	    dbg_prtwordlist(level+1, w->alt);
	    printf("%*s}", level*4, "");
	}
	printf("\n");
    }
}
Commit	Line	Data
d7482997	1	/*
	2	* main.c: command line parsing and top level
	3	*/
	4
c8fb54d2	5	#include <assert.h>
7e976207	6	#include <locale.h>
d7482997	7	#include <stdio.h>
	8	#include <stdlib.h>
	9	#include "halibut.h"
	10
	11	static void dbg_prtsource(paragraph *sourceform);
	12	static void dbg_prtwordlist(int level, word *w);
	13	static void dbg_prtkws(keywordlist *kws);
	14
43341922	15	static const struct pre_backend {
	16	void (func)(paragraph , keywordlist , indexdata *);
	17	int bitfield;
	18	} pre_backends[] = {
	19	{paper_pre_backend, 0x0001}
	20	};
	21
c8fb54d2	22	static const struct backend {
c8fb54d2	23	char *name;
43341922	24	void (func)(paragraph , keywordlist , indexdata , void *);
ba9c1487	25	paragraph (filename)(char *filename);
43341922	26	int bitfield, prebackend_bitfield;
c8fb54d2	27	} backends[] = {
43341922	28	{"text", text_backend, text_config_filename, 0x0001, 0},
78c73085	29	{"xhtml", html_backend, html_config_filename, 0x0002, 0},
78c73085	30	{"html", html_backend, html_config_filename, 0x0002, 0},
43341922	31	{"hlp", whlp_backend, whlp_config_filename, 0x0004, 0},
	32	{"whlp", whlp_backend, whlp_config_filename, 0x0004, 0},
	33	{"winhelp", whlp_backend, whlp_config_filename, 0x0004, 0},
	34	{"man", man_backend, man_config_filename, 0x0008, 0},
	35	{"info", info_backend, info_config_filename, 0x0010, 0},
	36	{"ps", ps_backend, ps_config_filename, 0x0020, 0x0001},
	37	{"pdf", pdf_backend, pdf_config_filename, 0x0040, 0x0001},
c8fb54d2	38	};
c8fb54d2	39
d7482997	40	int main(int argc, char **argv) {
d7482997	41	char **infiles;
d7482997	42	int nfiles;
	43	int nogo;
	44	int errs;
	45	int reportcols;
62a4b06b	46	int list_fonts;
675958c3	47	int input_charset;
d7482997	48	int debug;
43341922	49	int backendbits, prebackbits;
c8fb54d2	50	int k, b;
6a0b9d08	51	paragraph cfg, cfg_tail;
43341922	52	void *pre_backend_data[16];
d7482997	53
740a7d6a	54	/*
	55	* Use the specified locale everywhere. It'll be used for
	56	* output of error messages, and as the default character set
	57	* for input files if one is not explicitly specified.
	58	*
	59	* However, we need to use standard numeric formatting for
	60	* output of things like PDF.
	61	*/
7e976207	62	setlocale(LC_ALL, "");
740a7d6a	63	setlocale(LC_NUMERIC, "C");
7e976207	64
d7482997	65	/*
	66	* Set up initial (default) parameters.
	67	*/
f1530049	68	infiles = snewn(argc, char *);
d7482997	69	nfiles = 0;
	70	nogo = errs = FALSE;
	71	reportcols = 0;
62a4b06b	72	list_fonts = 0;
675958c3	73	input_charset = CS_ASCII;
d7482997	74	debug = 0;
c8fb54d2	75	backendbits = 0;
6a0b9d08	76	cfg = cfg_tail = NULL;
d7482997	77
	78	if (argc == 1) {
	79	usage();
	80	exit(EXIT_SUCCESS);
	81	}
	82
	83	/*
	84	* Parse command line arguments.
	85	*/
	86	while (--argc) {
	87	char p = ++argv;
d26171a6	88	if (*p == '-' && p[1]) {
d7482997	89	/*
	90	* An option.
	91	*/
	92	while (p && *++p) {
	93	char c = *p;
	94	switch (c) {
	95	case '-':
	96	/*
	97	* Long option.
	98	*/
	99	{
	100	char opt, val;
	101	opt = p++; /* opt will have _one_ leading - */
	102	while (p && p != '=')
	103	p++; /* find end of option */
	104	if (*p == '=') {
	105	*p++ = '\0';
	106	val = p;
	107	} else
	108	val = NULL;
c8fb54d2	109
	110	assert(opt[0] == '-');
	111	for (k = 0; k < (int)lenof(backends); k++)
	112	if (!strcmp(opt+1, backends[k].name)) {
	113	backendbits \|= backends[k].bitfield;
ba9c1487	114	if (val) {
	115	paragraph *p = backends[k].filename(val);
	116	assert(p);
	117	if (cfg_tail)
	118	cfg_tail->next = p;
	119	else
	120	cfg = p;
	121	while (p->next)
	122	p = p->next;
	123	cfg_tail = p;
	124	}
c8fb54d2	125	break;
	126	}
	127	if (k < (int)lenof(backends)) {
	128	/* do nothing */;
675958c3	129	} else if (!strcmp(opt, "-input-charset")) {
	130	if (!val) {
	131	errs = TRUE, error(err_optnoarg, opt);
	132	} else {
	133	int charset = charset_from_localenc(val);
	134	if (charset == CS_NONE) {
	135	errs = TRUE, error(err_cmdcharset, val);
	136	} else {
	137	input_charset = charset;
	138	}
	139	}
c8fb54d2	140	} else if (!strcmp(opt, "-help")) {
d7482997	141	help();
	142	nogo = TRUE;
	143	} else if (!strcmp(opt, "-version")) {
	144	showversion();
	145	nogo = TRUE;
	146	} else if (!strcmp(opt, "-licence") \|\|
	147	!strcmp(opt, "-license")) {
	148	licence();
	149	nogo = TRUE;
f336fa9a	150	} else if (!strcmp(opt, "-list-charsets")) {
	151	listcharsets();
	152	nogo = TRUE;
62a4b06b	153	} else if (!strcmp(opt, "-list-fonts")) {
62a4b06b	154	list_fonts = TRUE;
d7482997	155	} else if (!strcmp(opt, "-precise")) {
	156	reportcols = 1;
	157	} else {
	158	errs = TRUE, error(err_nosuchopt, opt);
	159	}
	160	}
	161	p = NULL;
	162	break;
	163	case 'h':
	164	case 'V':
	165	case 'L':
	166	case 'P':
	167	case 'd':
	168	/*
	169	* Option requiring no parameter.
	170	*/
	171	switch (c) {
	172	case 'h':
	173	help();
	174	nogo = TRUE;
	175	break;
	176	case 'V':
	177	showversion();
	178	nogo = TRUE;
	179	break;
	180	case 'L':
	181	licence();
	182	nogo = TRUE;
	183	break;
	184	case 'P':
	185	reportcols = 1;
	186	break;
	187	case 'd':
	188	debug = TRUE;
	189	break;
	190	}
	191	break;
6a0b9d08	192	case 'C':
d7482997	193	/*
	194	* Option requiring parameter.
	195	*/
	196	p++;
	197	if (!*p && argc > 1)
	198	--argc, p = *++argv;
	199	else if (!*p) {
	200	char opt[2];
	201	opt[0] = c;
	202	opt[1] = '\0';
	203	errs = TRUE, error(err_optnoarg, opt);
	204	}
	205	/*
	206	* Now c is the option and p is the parameter.
	207	*/
	208	switch (c) {
6a0b9d08	209	case 'C':
	210	/*
	211	* -C means we split our argument up into
	212	* colon-separated chunks and assemble them
	213	* into a config paragraph.
	214	*/
	215	{
e4ea58f8	216	char s = dupstr(p), q, *r;
6a0b9d08	217	paragraph *para;
6a0b9d08	218
e4ea58f8	219	para = cmdline_cfg_new();
6a0b9d08	220
e4ea58f8	221	q = r = s;
6a0b9d08	222	while (*q) {
6a0b9d08	223	if (*q == ':') {
e4ea58f8	224	*r = '\0';
675958c3	225	/* XXX ad-hoc diagnostic */
	226	if (!strcmp(s, "input-charset"))
	227	error(err_futileopt, "Cinput-charset",
	228	"; use --input-charset");
e4ea58f8	229	cmdline_cfg_add(para, s);
e4ea58f8	230	r = s;
6a0b9d08	231	} else {
	232	if (*q == '\\' && q[1])
	233	q++;
e4ea58f8	234	r++ = q;
6a0b9d08	235	}
	236	q++;
	237	}
57e17355	238	*r = '\0';
e4ea58f8	239	cmdline_cfg_add(para, s);
6a0b9d08	240
	241	if (cfg_tail)
	242	cfg_tail->next = para;
	243	else
	244	cfg = para;
	245	cfg_tail = para;
	246	}
d7482997	247	break;
	248	}
	249	p = NULL; /* prevent continued processing */
	250	break;
	251	default:
	252	/*
	253	* Unrecognised option.
	254	*/
	255	{
	256	char opt[2];
	257	opt[0] = c;
	258	opt[1] = '\0';
	259	errs = TRUE, error(err_nosuchopt, opt);
	260	}
	261	}
	262	}
	263	} else {
	264	/*
	265	* A non-option argument.
	266	*/
d26171a6	267	if (!strcmp(p, "-"))
	268	infiles[nfiles++] = NULL; /* special case: read stdin */
	269	else
	270	infiles[nfiles++] = p;
d7482997	271	}
	272	}
	273
	274	if (errs)
	275	exit(EXIT_FAILURE);
	276	if (nogo)
	277	exit(EXIT_SUCCESS);
	278
	279	/*
	280	* Do the work.
	281	*/
62a4b06b	282	if (nfiles == 0 && !list_fonts) {
d7482997	283	error(err_noinput);
	284	usage();
	285	exit(EXIT_FAILURE);
	286	}
	287
	288	{
	289	input in;
	290	paragraph sourceform, p;
	291	indexdata *idx;
	292	keywordlist *keywords;
	293
	294	in.filenames = infiles;
	295	in.nfiles = nfiles;
	296	in.currfp = NULL;
	297	in.currindex = 0;
	298	in.npushback = in.pushbacksize = 0;
	299	in.pushback = NULL;
	300	in.reportcols = reportcols;
	301	in.stack = NULL;
675958c3	302	in.defcharset = input_charset;
d7482997	303
	304	idx = make_index();
	305
	306	sourceform = read_input(&in, idx);
62a4b06b	307	if (list_fonts) {
	308	listfonts();
	309	exit(EXIT_SUCCESS);
	310	}
d7482997	311	if (!sourceform)
	312	exit(EXIT_FAILURE);
	313
6a0b9d08	314	/*
	315	* Append the config directives acquired from the command
	316	* line.
	317	*/
	318	{
	319	paragraph *end;
	320
	321	end = sourceform;
	322	while (end && end->next)
	323	end = end->next;
	324	assert(end);
	325
	326	end->next = cfg;
	327	}
	328
d7482997	329	sfree(in.pushback);
d7482997	330
d7482997	331	sfree(infiles);
	332
	333	keywords = get_keywords(sourceform);
	334	if (!keywords)
	335	exit(EXIT_FAILURE);
	336	gen_citations(sourceform, keywords);
	337	subst_keywords(sourceform, keywords);
	338
	339	for (p = sourceform; p; p = p->next)
	340	if (p->type == para_IM)
f4551933	341	index_merge(idx, TRUE, p->keyword, p->words, &p->fpos);
d7482997	342
	343	build_index(idx);
	344
bb9e7835	345	/*
	346	* Set up attr_First / attr_Last / attr_Always, in the main
	347	* document and in the index entries.
	348	*/
	349	for (p = sourceform; p; p = p->next)
	350	mark_attr_ends(p->words);
	351	{
	352	int i;
	353	indexentry *entry;
	354
	355	for (i = 0; (entry = index234(idx->entries, i)) != NULL; i++)
	356	mark_attr_ends(entry->text);
	357	}
	358
d7482997	359	if (debug) {
	360	index_debug(idx);
	361	dbg_prtkws(keywords);
	362	dbg_prtsource(sourceform);
	363	}
	364
c8fb54d2	365	/*
43341922	366	* Select and run the pre-backends.
	367	*/
	368	prebackbits = 0;
	369	for (k = 0; k < (int)lenof(backends); k++)
	370	if (backendbits == 0 \|\| (backendbits & backends[k].bitfield))
	371	prebackbits \|= backends[k].prebackend_bitfield;
	372	for (k = 0; k < (int)lenof(pre_backends); k++)
	373	if (prebackbits & pre_backends[k].bitfield) {
	374	assert(k < (int)lenof(pre_backend_data));
	375	pre_backend_data[k] =
	376	pre_backends[k].func(sourceform, keywords, idx);
	377	}
	378
	379	/*
c8fb54d2	380	* Run the selected set of backends.
	381	*/
	382	for (k = b = 0; k < (int)lenof(backends); k++)
	383	if (b != backends[k].bitfield) {
	384	b = backends[k].bitfield;
43341922	385	if (backendbits == 0 \|\| (backendbits & b)) {
	386	void *pbd = NULL;
	387	int pbb = backends[k].prebackend_bitfield;
	388	int m;
	389
	390	for (m = 0; m < (int)lenof(pre_backends); m++)
	391	if (pbb & pre_backends[m].bitfield) {
	392	assert(m < (int)lenof(pre_backend_data));
	393	pbd = pre_backend_data[m];
	394	break;
	395	}
	396
	397	backends[k].func(sourceform, keywords, idx, pbd);
	398	}
c8fb54d2	399	}
d7482997	400
	401	free_para_list(sourceform);
	402	free_keywords(keywords);
	403	cleanup_index(idx);
	404	}
	405
	406	return 0;
	407	}
	408
	409	static void dbg_prtsource(paragraph *sourceform) {
	410	/*
	411	* Output source form in debugging format.
	412	*/
	413
	414	paragraph *p;
	415	for (p = sourceform; p; p = p->next) {
	416	wchar_t *wp;
	417	printf("para %d ", p->type);
	418	if (p->keyword) {
	419	wp = p->keyword;
	420	while (*wp) {
	421	putchar('\"');
	422	for (; *wp; wp++)
	423	putchar(*wp);
	424	putchar('\"');
	425	if (*++wp)
	426	printf(", ");
	427	}
	428	} else
	429	printf("(no keyword)");
	430	printf(" {\n");
	431	dbg_prtwordlist(1, p->words);
	432	printf("}\n");
	433	}
	434	}
	435
	436	static void dbg_prtkws(keywordlist *kws) {
	437	/*
	438	* Output keywords in debugging format.
	439	*/
	440
	441	int i;
	442	keyword *kw;
	443
	444	for (i = 0; (kw = index234(kws->keys, i)) != NULL; i++) {
	445	wchar_t *wp;
	446	printf("keyword ");
	447	wp = kw->key;
	448	while (*wp) {
	449	putchar('\"');
	450	for (; *wp; wp++)
	451	putchar(*wp);
	452	putchar('\"');
	453	if (*++wp)
	454	printf(", ");
	455	}
	456	printf(" {\n");
	457	dbg_prtwordlist(1, kw->text);
	458	printf("}\n");
	459	}
	460	}
	461
	462	static void dbg_prtwordlist(int level, word *w) {
	463	for (; w; w = w->next) {
464	wchar_t *wp;
465	printf("%sword %d ", level4, "", w->type);
466	if (w->text) {
467	printf("\"");
468	for (wp = w->text; *wp; wp++)
469	putchar(*wp);
470	printf("\"");
471	} else
472	printf("(no text)");
14b072e2	473	if (w->breaks)
14b072e2	474	printf(" [breaks]");
d7482997	475	if (w->alt) {
	476	printf(" alt = {\n");
	477	dbg_prtwordlist(level+1, w->alt);
	478	printf("%s}", level4, "");
	479	}
	480	printf("\n");
	481	}
	482	}