[fontconfig.git] / doc / edit-sgml.c

/*
 * $Id$
 *
 * Copyright © 2003 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

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

static void *
New (int size);

static void *
Reallocate (void *p, int size);

static void
Dispose (void *p);

typedef enum { False, True } Bool;

typedef struct {
    char    *buf;
    int	    size;
    int	    len;
} String;

static String *
StringNew (void);

static void
StringAdd (String *s, char c);

static void
StringAddString (String *s, char *buf);

static String *
StringMake (char *buf);

static void
StringDel (String *s);

static void
StringPut (FILE *f, String *s);

static void
StringDispose (String *s);

typedef struct {
    String  *tag;
    String  *text;
} Replace;

static Replace *
ReplaceNew (void);

static void
ReplaceDispose (Replace *r);

static void
Bail (const char *format, const char *arg);

static Replace *
ReplaceRead (FILE *f);

typedef struct _replaceList {
    struct _replaceList	*next;
    Replace		*r;
} ReplaceList;

static ReplaceList *
ReplaceListNew (Replace *r, ReplaceList *next);

static void
ReplaceListDispose (ReplaceList *l);

typedef struct {
    ReplaceList	*head;
} ReplaceSet;

static ReplaceSet *
ReplaceSetNew (void);

static void
ReplaceSetDispose (ReplaceSet *s);

static void
ReplaceSetAdd (ReplaceSet *s, Replace *r);

static Replace *
ReplaceSetFind (ReplaceSet *s, char *tag);

static ReplaceSet *
ReplaceSetRead (FILE *f);

typedef struct _skipStack {
    struct _skipStack	*prev;
    int			skipping;
} SkipStack;

static SkipStack *
SkipStackPush (SkipStack *prev, int skipping);

static SkipStack *
SkipStackPop (SkipStack *prev);

typedef struct _loopStack {
    struct _loopStack	*prev;
    String		*tag;
    String		*extra;
    long		pos;
} LoopStack;

static LoopStack *
LoopStackPush (LoopStack *prev, FILE *f, char *tag);

static LoopStack *
LoopStackLoop (ReplaceSet *rs, LoopStack *ls, FILE *f);

static void
LineSkip (FILE *f);

static void
DoReplace (FILE *f, ReplaceSet *s);

#define STRING_INIT 128

static void *
New (int size)
{
    void    *m = malloc (size);
    if (!m)
	abort ();
    return m;
}

static void *
Reallocate (void *p, int size)
{
    void    *r = realloc (p, size);

    if (!r)
	abort ();
    return r;
}

static void
Dispose (void *p)
{
    free (p);
}

static String *
StringNew (void)
{
    String  *s;

    s = New (sizeof (String));
    s->buf = New (STRING_INIT);
    s->size = STRING_INIT - 1;
    s->buf[0] = '\0';
    s->len = 0;
    return s;
}

static void
StringAdd (String *s, char c)
{
    if (s->len == s->size)
	s->buf = Reallocate (s->buf, (s->size *= 2) + 1);
    s->buf[s->len++] = c;
    s->buf[s->len] = '\0';
}

static void
StringAddString (String *s, char *buf)
{
    while (*buf)
	StringAdd (s, *buf++);
}

static String *
StringMake (char *buf)
{
    String  *s = StringNew ();
    StringAddString (s, buf);
    return s;
}

static void
StringDel (String *s)
{
    if (s->len)
	s->buf[--s->len] = '\0';
}

static void
StringPut (FILE *f, String *s)
{
    char    *b = s->buf;

    while (*b)
	putc (*b++, f);
}

#define StringLast(s)	((s)->len ? (s)->buf[(s)->len - 1] : '\0')

static void
StringDispose (String *s)
{
    Dispose (s->buf);
    Dispose (s);
}

static Replace *
ReplaceNew (void)
{
    Replace *r = New (sizeof (Replace));
    r->tag = StringNew ();
    r->text = StringNew ();
    return r;
}

static void
ReplaceDispose (Replace *r)
{
    StringDispose (r->tag);
    StringDispose (r->text);
    Dispose (r);
}

static void
Bail (const char *format, const char *arg)
{
    fprintf (stderr, "fatal: ");
    fprintf (stderr, format, arg);
    fprintf (stderr, "\n");
    exit (1);
}

static Replace *
ReplaceRead (FILE *f)
{
    int	    c;
    Replace *r;

    while ((c = getc (f)) != '@')
    {
	if (c == EOF)
	    return 0;
    }
    r = ReplaceNew();
    while ((c = getc (f)) != '@')
    {
	if (c == EOF)
	{
	    ReplaceDispose (r);
	    return 0;
	}
	if (isspace (c))
	    Bail ("invalid character after tag %s", r->tag->buf);
	StringAdd (r->tag, c);
    }
    if (r->tag->buf[0] == '\0')
    {
	ReplaceDispose (r);
	return 0;
    }
    while (isspace ((c = getc (f))))
	;
    ungetc (c, f);
    while ((c = getc (f)) != '@' && c != EOF)
	StringAdd (r->text, c);
    if (c == '@')
	ungetc (c, f);
    while (isspace (StringLast (r->text)))
	StringDel (r->text);
    if (StringLast(r->text) == '%')
    {
	StringDel (r->text);
	StringAdd (r->text, ' ');
    }
    return r;
}

static ReplaceList *
ReplaceListNew (Replace *r, ReplaceList *next)
{
    ReplaceList	*l = New (sizeof (ReplaceList));
    l->r = r;
    l->next = next;
    return l;
}

static void
ReplaceListDispose (ReplaceList *l)
{
    if (l)
    {
	ReplaceListDispose (l->next);
	ReplaceDispose (l->r);
	Dispose (l);
    }
}

static ReplaceSet *
ReplaceSetNew (void)
{
    ReplaceSet	*s = New (sizeof (ReplaceSet));
    s->head = 0;
    return s;
}

static void
ReplaceSetDispose (ReplaceSet *s)
{
    ReplaceListDispose (s->head);
    Dispose (s);
}

static void
ReplaceSetAdd (ReplaceSet *s, Replace *r)
{
    s->head = ReplaceListNew (r, s->head);
}

static Replace *
ReplaceSetFind (ReplaceSet *s, char *tag)
{
    ReplaceList	*l;

    for (l = s->head; l; l = l->next)
	if (!strcmp (tag, l->r->tag->buf))
	    return l->r;
    return 0;
}

static ReplaceSet *
ReplaceSetRead (FILE *f)
{
    ReplaceSet	*s = ReplaceSetNew ();
    Replace	*r;

    while ((r = ReplaceRead (f)))
    {
	while (ReplaceSetFind (s, r->tag->buf))
	    StringAdd (r->tag, '+');
	ReplaceSetAdd (s, r);
    }
    if (!s->head)
    {
	ReplaceSetDispose (s);
	s = 0;
    }
    return s;
}

static SkipStack *
SkipStackPush (SkipStack *prev, int skipping)
{
    SkipStack	*ss = New (sizeof (SkipStack));
    ss->prev = prev;
    ss->skipping = skipping;
    return ss;
}

static SkipStack *
SkipStackPop (SkipStack *prev)
{
    SkipStack	*ss = prev->prev;
    Dispose (prev);
    return ss;
}

static LoopStack *
LoopStackPush (LoopStack *prev, FILE *f, char *tag)
{
    LoopStack	*ls = New (sizeof (LoopStack));
    ls->prev = prev;
    ls->tag = StringMake (tag);
    ls->extra = StringNew ();
    ls->pos = ftell (f);
    return ls;
}

static LoopStack *
LoopStackLoop (ReplaceSet *rs, LoopStack *ls, FILE *f)
{
    String	*s = StringMake (ls->tag->buf);
    LoopStack	*ret = ls;
    Bool	loop;

    StringAdd (ls->extra, '+');
    StringAddString (s, ls->extra->buf);
    loop = ReplaceSetFind (rs, s->buf) != 0;
    StringDispose (s);
    if (loop)
	fseek (f, ls->pos, SEEK_SET);
    else
    {
	ret = ls->prev;
	StringDispose (ls->tag);
	StringDispose (ls->extra);
	Dispose (ls);
    }
    return ret;
}

static void
LineSkip (FILE *f)
{
    int	c;

    while ((c = getc (f)) == '\n')
	;
    ungetc (c, f);
}

static void
DoReplace (FILE *f, ReplaceSet *s)
{
    int		c;
    String	*tag;
    Replace	*r;
    SkipStack	*ss = 0;
    LoopStack	*ls = 0;
    int		skipping = 0;

    while ((c = getc (f)) != EOF)
    {
	if (c == '@')
	{
	    tag = StringNew ();
	    while ((c = getc (f)) != '@')
	    {
		if (c == EOF)
		    abort ();
		StringAdd (tag, c);
	    }
	    if (ls)
		StringAddString (tag, ls->extra->buf);
	    switch (tag->buf[0]) {
	    case '?':
		ss = SkipStackPush (ss, skipping);
		if (!ReplaceSetFind (s, tag->buf + 1))
		    skipping++;
		LineSkip (f);
		break;
	    case ':':
		if (!ss)
		    abort ();
		if (ss->skipping == skipping)
		    ++skipping;
		else
		    --skipping;
		LineSkip (f);
		break;
	    case ';':
		skipping = ss->skipping;
		ss = SkipStackPop (ss);
		LineSkip (f);
		break;
	    case '{':
		ls = LoopStackPush (ls, f, tag->buf + 1);
		LineSkip (f);
		break;
	    case '}':
		ls = LoopStackLoop (s, ls, f);
		LineSkip (f);
		break;
	    default:
		r = ReplaceSetFind (s, tag->buf);
		if (r && !skipping)
		    StringPut (stdout, r->text);
		break;
	    }
	    StringDispose (tag);
	}
	else if (!skipping)
	    putchar (c);
    }
}

int
main (int argc, char **argv)
{
    FILE	*f;
    ReplaceSet	*s;

    if (!argv[1])
	Bail ("usage: %s <template.sgml>", argv[0]);
    f = fopen (argv[1], "r");
    if (!f)
    {
	Bail ("can't open file %s", argv[1]);
	exit (1);
    }
    while ((s = ReplaceSetRead (stdin)))
    {
	DoReplace (f, s);
	ReplaceSetDispose (s);
	rewind (f);
    }
    if (ferror (stdout))
	Bail ("%s", "error writing output");
    exit (0);
}
Commit	Line	Data
5e1f56b5 KP	1	/*
	2	* $Id$
	3	*
46b51147	4	* Copyright © 2003 Keith Packard
5e1f56b5 KP	5	*
	6	* Permission to use, copy, modify, distribute, and sell this software and its
	7	* documentation for any purpose is hereby granted without fee, provided that
	8	* the above copyright notice appear in all copies and that both that
	9	* copyright notice and this permission notice appear in supporting
	10	* documentation, and that the name of Keith Packard not be used in
	11	* advertising or publicity pertaining to distribution of the software without
	12	* specific, written prior permission. Keith Packard makes no
	13	* representations about the suitability of this software for any purpose. It
	14	* is provided "as is" without express or implied warranty.
	15	*
	16	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	17	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	18	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	19	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	20	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	21	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	22	* PERFORMANCE OF THIS SOFTWARE.
	23	*/
	24
	25	#include <stdio.h>
	26	#include <stdlib.h>
12d49d3c	27	#include <string.h>
5e1f56b5 KP	28	#include <ctype.h>
5e1f56b5 KP	29
34cd0514 CW	30	static void *
	31	New (int size);
	32
	33	static void *
	34	Reallocate (void *p, int size);
	35
	36	static void
	37	Dispose (void *p);
	38
5e1f56b5 KP	39	typedef enum { False, True } Bool;
	40
	41	typedef struct {
	42	char *buf;
	43	int size;
	44	int len;
	45	} String;
	46
34cd0514 CW	47	static String *
	48	StringNew (void);
	49
	50	static void
	51	StringAdd (String *s, char c);
	52
	53	static void
	54	StringAddString (String s, char buf);
	55
	56	static String *
	57	StringMake (char *buf);
	58
	59	static void
	60	StringDel (String *s);
	61
	62	static void
	63	StringPut (FILE f, String s);
	64
	65	static void
	66	StringDispose (String *s);
	67
	68	typedef struct {
	69	String *tag;
	70	String *text;
	71	} Replace;
	72
	73	static Replace *
	74	ReplaceNew (void);
	75
	76	static void
	77	ReplaceDispose (Replace *r);
	78
	79	static void
67accef4	80	Bail (const char format, const char arg);
34cd0514 CW	81
	82	static Replace *
	83	ReplaceRead (FILE *f);
	84
	85	typedef struct _replaceList {
	86	struct _replaceList *next;
	87	Replace *r;
	88	} ReplaceList;
	89
	90	static ReplaceList *
	91	ReplaceListNew (Replace r, ReplaceList next);
	92
	93	static void
	94	ReplaceListDispose (ReplaceList *l);
	95
	96	typedef struct {
	97	ReplaceList *head;
	98	} ReplaceSet;
	99
	100	static ReplaceSet *
	101	ReplaceSetNew (void);
	102
	103	static void
	104	ReplaceSetDispose (ReplaceSet *s);
	105
	106	static void
	107	ReplaceSetAdd (ReplaceSet s, Replace r);
	108
	109	static Replace *
	110	ReplaceSetFind (ReplaceSet s, char tag);
	111
	112	static ReplaceSet *
	113	ReplaceSetRead (FILE *f);
	114
	115	typedef struct _skipStack {
	116	struct _skipStack *prev;
	117	int skipping;
	118	} SkipStack;
	119
	120	static SkipStack *
	121	SkipStackPush (SkipStack *prev, int skipping);
	122
	123	static SkipStack *
	124	SkipStackPop (SkipStack *prev);
	125
	126	typedef struct _loopStack {
	127	struct _loopStack *prev;
	128	String *tag;
	129	String *extra;
	130	long pos;
	131	} LoopStack;
	132
	133	static LoopStack *
	134	LoopStackPush (LoopStack prev, FILE f, char *tag);
	135
	136	static LoopStack *
	137	LoopStackLoop (ReplaceSet rs, LoopStack ls, FILE *f);
	138
	139	static void
	140	LineSkip (FILE *f);
	141
	142	static void
	143	DoReplace (FILE f, ReplaceSet s);
	144
5e1f56b5 KP	145	#define STRING_INIT 128
5e1f56b5 KP	146
34cd0514	147	static void *
5e1f56b5 KP	148	New (int size)
	149	{
	150	void *m = malloc (size);
	151	if (!m)
	152	abort ();
	153	return m;
	154	}
	155
34cd0514	156	static void *
5e1f56b5 KP	157	Reallocate (void *p, int size)
	158	{
	159	void *r = realloc (p, size);
	160
	161	if (!r)
	162	abort ();
	163	return r;
	164	}
	165
34cd0514	166	static void
5e1f56b5 KP	167	Dispose (void *p)
	168	{
	169	free (p);
	170	}
	171
34cd0514	172	static String *
5e1f56b5 KP	173	StringNew (void)
	174	{
	175	String *s;
	176
	177	s = New (sizeof (String));
	178	s->buf = New (STRING_INIT);
	179	s->size = STRING_INIT - 1;
	180	s->buf[0] = '\0';
	181	s->len = 0;
	182	return s;
	183	}
	184
34cd0514	185	static void
5e1f56b5 KP	186	StringAdd (String *s, char c)
	187	{
	188	if (s->len == s->size)
	189	s->buf = Reallocate (s->buf, (s->size *= 2) + 1);
	190	s->buf[s->len++] = c;
	191	s->buf[s->len] = '\0';
	192	}
	193
34cd0514	194	static void
5e1f56b5 KP	195	StringAddString (String s, char buf)
	196	{
	197	while (*buf)
	198	StringAdd (s, *buf++);
	199	}
	200
34cd0514	201	static String *
5e1f56b5 KP	202	StringMake (char *buf)
	203	{
	204	String *s = StringNew ();
	205	StringAddString (s, buf);
	206	return s;
	207	}
	208
34cd0514	209	static void
5e1f56b5 KP	210	StringDel (String *s)
	211	{
	212	if (s->len)
	213	s->buf[--s->len] = '\0';
	214	}
	215
34cd0514	216	static void
5e1f56b5 KP	217	StringPut (FILE f, String s)
	218	{
	219	char *b = s->buf;
	220
	221	while (*b)
	222	putc (*b++, f);
	223	}
	224
	225	#define StringLast(s) ((s)->len ? (s)->buf[(s)->len - 1] : '\0')
	226
34cd0514	227	static void
5e1f56b5 KP	228	StringDispose (String *s)
	229	{
	230	Dispose (s->buf);
	231	Dispose (s);
	232	}
	233
34cd0514	234	static Replace *
5e1f56b5 KP	235	ReplaceNew (void)
	236	{
	237	Replace *r = New (sizeof (Replace));
	238	r->tag = StringNew ();
	239	r->text = StringNew ();
	240	return r;
	241	}
	242
34cd0514	243	static void
5e1f56b5 KP	244	ReplaceDispose (Replace *r)
	245	{
	246	StringDispose (r->tag);
	247	StringDispose (r->text);
	248	Dispose (r);
	249	}
	250
34cd0514	251	static void
67accef4	252	Bail (const char format, const char arg)
39381776 KP	253	{
	254	fprintf (stderr, "fatal: ");
	255	fprintf (stderr, format, arg);
	256	fprintf (stderr, "\n");
	257	exit (1);
	258	}
	259
34cd0514	260	static Replace *
5e1f56b5 KP	261	ReplaceRead (FILE *f)
	262	{
	263	int c;
	264	Replace *r;
	265
	266	while ((c = getc (f)) != '@')
	267	{
	268	if (c == EOF)
	269	return 0;
	270	}
	271	r = ReplaceNew();
	272	while ((c = getc (f)) != '@')
	273	{
	274	if (c == EOF)
	275	{
	276	ReplaceDispose (r);
	277	return 0;
	278	}
39381776 KP	279	if (isspace (c))
39381776 KP	280	Bail ("invalid character after tag %s", r->tag->buf);
5e1f56b5 KP	281	StringAdd (r->tag, c);
	282	}
	283	if (r->tag->buf[0] == '\0')
	284	{
	285	ReplaceDispose (r);
	286	return 0;
	287	}
	288	while (isspace ((c = getc (f))))
	289	;
	290	ungetc (c, f);
	291	while ((c = getc (f)) != '@' && c != EOF)
	292	StringAdd (r->text, c);
	293	if (c == '@')
	294	ungetc (c, f);
b219ac6b	295	while (isspace (StringLast (r->text)))
5e1f56b5	296	StringDel (r->text);
61895ed1 KP	297	if (StringLast(r->text) == '%')
	298	{
	299	StringDel (r->text);
	300	StringAdd (r->text, ' ');
	301	}
5e1f56b5 KP	302	return r;
	303	}
	304
34cd0514	305	static ReplaceList *
5e1f56b5 KP	306	ReplaceListNew (Replace r, ReplaceList next)
	307	{
	308	ReplaceList *l = New (sizeof (ReplaceList));
	309	l->r = r;
	310	l->next = next;
	311	return l;
	312	}
	313
34cd0514	314	static void
5e1f56b5 KP	315	ReplaceListDispose (ReplaceList *l)
	316	{
	317	if (l)
	318	{
	319	ReplaceListDispose (l->next);
	320	ReplaceDispose (l->r);
	321	Dispose (l);
	322	}
	323	}
	324
34cd0514	325	static ReplaceSet *
5e1f56b5 KP	326	ReplaceSetNew (void)
	327	{
	328	ReplaceSet *s = New (sizeof (ReplaceSet));
	329	s->head = 0;
	330	return s;
	331	}
	332
34cd0514	333	static void
5e1f56b5 KP	334	ReplaceSetDispose (ReplaceSet *s)
	335	{
	336	ReplaceListDispose (s->head);
	337	Dispose (s);
	338	}
	339
34cd0514	340	static void
5e1f56b5 KP	341	ReplaceSetAdd (ReplaceSet s, Replace r)
	342	{
	343	s->head = ReplaceListNew (r, s->head);
	344	}
	345
34cd0514	346	static Replace *
5e1f56b5 KP	347	ReplaceSetFind (ReplaceSet s, char tag)
	348	{
	349	ReplaceList *l;
	350
	351	for (l = s->head; l; l = l->next)
	352	if (!strcmp (tag, l->r->tag->buf))
	353	return l->r;
	354	return 0;
	355	}
	356
34cd0514	357	static ReplaceSet *
5e1f56b5 KP	358	ReplaceSetRead (FILE *f)
	359	{
	360	ReplaceSet *s = ReplaceSetNew ();
	361	Replace *r;
	362
	363	while ((r = ReplaceRead (f)))
	364	{
	365	while (ReplaceSetFind (s, r->tag->buf))
	366	StringAdd (r->tag, '+');
	367	ReplaceSetAdd (s, r);
	368	}
	369	if (!s->head)
	370	{
	371	ReplaceSetDispose (s);
	372	s = 0;
	373	}
	374	return s;
	375	}
	376
34cd0514	377	static SkipStack *
5e1f56b5 KP	378	SkipStackPush (SkipStack *prev, int skipping)
	379	{
	380	SkipStack *ss = New (sizeof (SkipStack));
	381	ss->prev = prev;
	382	ss->skipping = skipping;
	383	return ss;
	384	}
	385
34cd0514	386	static SkipStack *
5e1f56b5 KP	387	SkipStackPop (SkipStack *prev)
	388	{
	389	SkipStack *ss = prev->prev;
	390	Dispose (prev);
	391	return ss;
	392	}
	393
34cd0514	394	static LoopStack *
5e1f56b5 KP	395	LoopStackPush (LoopStack prev, FILE f, char *tag)
	396	{
	397	LoopStack *ls = New (sizeof (LoopStack));
	398	ls->prev = prev;
	399	ls->tag = StringMake (tag);
	400	ls->extra = StringNew ();
	401	ls->pos = ftell (f);
	402	return ls;
	403	}
	404
34cd0514	405	static LoopStack *
5e1f56b5 KP	406	LoopStackLoop (ReplaceSet rs, LoopStack ls, FILE *f)
	407	{
	408	String *s = StringMake (ls->tag->buf);
	409	LoopStack *ret = ls;
	410	Bool loop;
	411
	412	StringAdd (ls->extra, '+');
	413	StringAddString (s, ls->extra->buf);
	414	loop = ReplaceSetFind (rs, s->buf) != 0;
	415	StringDispose (s);
	416	if (loop)
	417	fseek (f, ls->pos, SEEK_SET);
	418	else
	419	{
	420	ret = ls->prev;
	421	StringDispose (ls->tag);
	422	StringDispose (ls->extra);
	423	Dispose (ls);
	424	}
	425	return ret;
	426	}
	427
34cd0514	428	static void
5e1f56b5 KP	429	LineSkip (FILE *f)
	430	{
	431	int c;
	432
	433	while ((c = getc (f)) == '\n')
	434	;
	435	ungetc (c, f);
	436	}
	437
34cd0514	438	static void
5e1f56b5 KP	439	DoReplace (FILE f, ReplaceSet s)
	440	{
	441	int c;
	442	String *tag;
	443	Replace *r;
	444	SkipStack *ss = 0;
	445	LoopStack *ls = 0;
	446	int skipping = 0;
	447
	448	while ((c = getc (f)) != EOF)
	449	{
	450	if (c == '@')
	451	{
	452	tag = StringNew ();
	453	while ((c = getc (f)) != '@')
	454	{
	455	if (c == EOF)
	456	abort ();
	457	StringAdd (tag, c);
	458	}
	459	if (ls)
	460	StringAddString (tag, ls->extra->buf);
	461	switch (tag->buf[0]) {
	462	case '?':
	463	ss = SkipStackPush (ss, skipping);
	464	if (!ReplaceSetFind (s, tag->buf + 1))
	465	skipping++;
	466	LineSkip (f);
	467	break;
	468	case ':':
	469	if (!ss)
	470	abort ();
	471	if (ss->skipping == skipping)
	472	++skipping;
	473	else
	474	--skipping;
	475	LineSkip (f);
	476	break;
	477	case ';':
	478	skipping = ss->skipping;
	479	ss = SkipStackPop (ss);
	480	LineSkip (f);
	481	break;
	482	case '{':
	483	ls = LoopStackPush (ls, f, tag->buf + 1);
	484	LineSkip (f);
	485	break;
	486	case '}':
	487	ls = LoopStackLoop (s, ls, f);
	488	LineSkip (f);
	489	break;
	490	default:
	491	r = ReplaceSetFind (s, tag->buf);
	492	if (r && !skipping)
	493	StringPut (stdout, r->text);
	494	break;
	495	}
	496	StringDispose (tag);
	497	}
	498	else if (!skipping)
	499	putchar (c);
	500	}
	501	}
	502
503	int
504	main (int argc, char **argv)
505	{
506	FILE *f;
507	ReplaceSet *s;
508
39381776 KP	509	if (!argv[1])
39381776 KP	510	Bail ("usage: %s <template.sgml>", argv[0]);
5e1f56b5 KP	511	f = fopen (argv[1], "r");
	512	if (!f)
	513	{
39381776	514	Bail ("can't open file %s", argv[1]);
5e1f56b5 KP	515	exit (1);
	516	}
	517	while ((s = ReplaceSetRead (stdin)))
	518	{
	519	DoReplace (f, s);
	520	ReplaceSetDispose (s);
	521	rewind (f);
	522	}
	523	if (ferror (stdout))
39381776	524	Bail ("%s", "error writing output");
5e1f56b5 KP	525	exit (0);
5e1f56b5 KP	526	}