[ia32rtools.git] / tools / asmproc.c

/*
 * ia32rtools
 * (C) notaz, 2013,2014
 *
 * This work is licensed under the terms of 3-clause BSD license.
 * See COPYING file in the top-level directory.
 */

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

#include "my_assert.h"
#include "my_str.h"
#include "common.h"

struct sl_item {
	char *name;
	unsigned int callsites:1;
	unsigned int found:1;
	unsigned int ignore_missing:1;
};

static int cmp_sym(const void *p1_, const void *p2_)
{
	const struct sl_item *p1 = p1_, *p2 = p2_;
	const char *s1 = p1->name, *s2 = p2->name;
	int i;

	if (*s1 == '_')
		s1++;
	if (*s2 == '_')
		s2++;

	for (i = 0; ; i++) {
		if ((s1[i] | s2[i]) == 0)
			break;

		if (s1[i] == s2[i])
			continue;

		if (s1[i] ==  0  && s2[i] == '@')
			break;
		if (s1[i] == '@' && s2[i] ==  0)
			break;

		return s1[i] - s2[i];
	}

	return 0;
}

static int cmp_sym_sort(const void *p1_, const void *p2_)
{
	const struct sl_item *p1 = p1_, *p2 = p2_;
	const char *s1 = p1->name, *s2 = p2->name;
	int ret;
	
	ret = cmp_sym(p1_, p2_);
	if (ret == 0) {
		printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
		exit(1);
	}
	return ret;
}

void read_list(struct sl_item **sl_in, int *cnt, int *alloc,
	FILE *f, int callsites, int ignore_missing)
{
	struct sl_item *sl = *sl_in;
	int c = *cnt;
	char line[256];
	char word[256];

	while (fgets(line, sizeof(line), f) != NULL) {
		next_word(word, sizeof(word), line);
		if (word[0] == 0 || word[0] == ';' || word[0] == '#')
			continue;

		sl[c].name = strdup(word);
		sl[c].callsites = callsites;
		sl[c].ignore_missing = ignore_missing;
		sl[c].found = 0;
		c++;

		if (c >= *alloc) {
			*alloc *= 2;
			sl = realloc(sl, *alloc * sizeof(sl[0]));
			my_assert_not(sl, NULL);
			memset(sl + c, 0, (*alloc - c) * sizeof(sl[0]));
		}
	}

	*sl_in = sl;
	*cnt = c;
}

const char *sym_use(const struct sl_item *sym, int is_rm)
{
	static char buf[256+3];
	int ret;

	ret = snprintf(buf, sizeof(buf), "%s%s",
	  is_rm ? "rm_" : "", sym->name);
	if (ret >= sizeof(buf)) {
		printf("truncation detected: '%s'\n", buf);
		exit(1);
	}

	return buf;
}

#define IS_OR2(w, x, y) (IS(w, x) || IS(w, y))
#define IS_OR3(w, x, y, z) (IS(w, x) || IS(w, y) || IS(w, z))

int main(int argc, char *argv[])
{
	struct sl_item *symlist, *sym, ssym = { NULL, };
	int patch_callsites = 0;
	int ignore_missing = 0;
	FILE *fout, *fin, *f;
	int symlist_alloc;
	int symlist_cnt;
	char line[256];
	char word[256];
	char word2[256];
	char word3[256];
	char word4[256];
	char word5[256];
	char word6[256];
	char func[256];
	char *p, *p2;
	int i;

	if (argc < 4) {
		printf("usage:\n%s <asmf_out> <asmf_in> [[-c][-i] <listf>]*>\n",
			argv[0]);
		printf("  -c - patch callsites\n"
					 "  -i - ignore missing syms\n");
		return 1;
	}

	symlist_alloc = 16;
	symlist_cnt = 0;
	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
	my_assert_not(symlist, NULL);

	for (i = 3; i < argc; i++) {
		if (strcmp(argv[i], "-c") == 0) {
			patch_callsites = 1;
			continue;
		}
		if (strcmp(argv[i], "-i") == 0) {
			ignore_missing = 1;
			continue;
		}

		f = fopen(argv[i], "r");
		my_assert_not(f, NULL);
		read_list(&symlist, &symlist_cnt, &symlist_alloc,
			f, patch_callsites, ignore_missing);
		fclose(f);

		patch_callsites = 0;
		ignore_missing = 0;
	}

	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);

#if 0
	printf("symlist:\n");
	for (i = 0; i < symlist_cnt; i++)
		printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
#endif

	fin = fopen(argv[2], "r");
	my_assert_not(fin, NULL);

	fout = fopen(argv[1], "w");
	my_assert_not(fout, NULL);

	while (fgets(line, sizeof(line), fin))
	{
		p = sskip(line);
		if (*p == 0 || *p == ';')
			goto pass;

		p = sskip(next_word(word, sizeof(word), p));
		if (*p == 0 || *p == ';')
			goto pass; // need at least 2 words

		p = next_word(word2, sizeof(word2), p);

		if (IS_OR2(word2, "proc", "endp")) {
			if (IS(word2, "proc"))
				strcpy(func, word);
			else
				func[0] = 0;

			ssym.name = word;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				sym->found = 1;
				fprintf(fout, "%s\t%s%s", sym_use(sym, 1), word2, p);
				continue;
			}
		}

		if (IS_OR2(word, "call", "jmp")) {
			ssym.name = word2;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\t%s\t%s%s", word,
					sym_use(sym, sym->callsites || IS(word2, func)), p);
				continue;
			}
		}

		if (IS(word, "public")) {
			ssym.name = word2;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\tpublic %s%s", sym_use(sym, 1), p);
				continue;
			}
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 3 words

		p = next_word(word3, sizeof(word3), p);

		// push offset <sym>
		if (IS(word, "push") && IS(word2, "offset")) {
			ssym.name = word3;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\t%s %s %s%s", word, word2,
				  sym_use(sym, sym->callsites || IS(word3, func)), p);
				continue;
			}
		}

		// jcc short <sym>
		if (word[0] == 'j' && IS(word2, "short") && !IS(word3, "exit")) {
			ssym.name = word3;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\t%s ", word);
				// for conditional "call", don't print 'short'
				if (IS(word3, func))
					fprintf(fout, "short ");
				fprintf(fout, "%s%s",
				  sym_use(sym, sym->callsites || IS(word3, func)), p);
				continue;
			}
		}

		// dd offset <sym>
		if (IS(word, "dd")
			&& (IS(word2, "offset") || strstr(p, "offset")))
		{
			fprintf(fout, "\t\tdd");
			p = next_word(word, sizeof(word), line);
			goto offset_loop;
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 4 words

		p = next_word(word4, sizeof(word4), p);

		// <name> dd offset <sym>
		if (IS(word2, "dd")
			&& (IS(word3, "offset") || strstr(p, "offset")))
		{
			fprintf(fout, "%s\tdd", word);
			p = next_word(word, sizeof(word), line);
			p = next_word(word, sizeof(word), p);
			goto offset_loop;
		}

		// mov <something>, offset <sym>
		// jcc <some> ptr <sym>
		if ( (IS(word, "mov") && IS(word3, "offset"))
		  || (word[0] == 'j' && IS(word3, "ptr")) ) {
			ssym.name = word4;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\t%s\t%s %s %s%s",
					word, word2, word3,
					sym_use(sym, sym->callsites), p);
				continue;
			}
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 5 words

		p = next_word(word5, sizeof(word5), p);

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 6 words

		p = next_word(word6, sizeof(word6), p);

		// <op> dword ptr <something>, offset <sym>
		if ( IS(word2, "dword") && IS(word3, "ptr")
		  && IS(word5, "offset") ) {
			ssym.name = word6;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
					word, word4, sym_use(sym, sym->callsites), p);
				continue;
			}
		}

pass:
		fwrite(line, 1, strlen(line), fout);
		continue;

offset_loop:
		while (1) {
			p2 = next_word(word, sizeof(word), p);
			if (word[0] == 0 || word[0] == ';') {
				break;
			}
			if (!IS(word, "offset")) {
				// pass through
				p2 = strstr(p, "offset");
				if (p2 == NULL)
					break;
				fwrite(p, 1, p2 - p, fout);
				p2 = next_word(word, sizeof(word), p2);
			}
			p = next_word(word, sizeof(word), p2);
			p2 = strchr(word, ',');
			if (p2)
				*p2 = 0;

			ssym.name = word;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			fprintf(fout, " offset %s%s",
				(sym != NULL) ? sym_use(sym, sym->callsites) : word,
				p2 ? "," : "");
		}
		fprintf(fout, "%s", p);
		continue;
	}

	for (i = 0; i < symlist_cnt; i++) {
		if (!symlist[i].found && !symlist[i].ignore_missing)
			printf("warning: sym '%s' not found\n", symlist[i].name);
	}

	fclose(fin);
	fclose(fout);

	return 0;
}

// vim:ts=2:shiftwidth=2
Commit	Line	Data
7637b6cc	1	/*
	2	* ia32rtools
	3	* (C) notaz, 2013,2014
	4	*
	5	* This work is licensed under the terms of 3-clause BSD license.
	6	* See COPYING file in the top-level directory.
	7	*/
	8
ede51255	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12
	13	#include "my_assert.h"
57e4efe9	14	#include "my_str.h"
30845119	15	#include "common.h"
ede51255	16
	17	struct sl_item {
	18	char *name;
368deb23	19	unsigned int callsites:1;
8022df01	20	unsigned int found:1;
87ccd363	21	unsigned int ignore_missing:1;
ede51255	22	};
	23
	24	static int cmp_sym(const void p1_, const void p2_)
	25	{
	26	const struct sl_item p1 = p1_, p2 = p2_;
	27	const char s1 = p1->name, s2 = p2->name;
	28	int i;
	29
7aca4698	30	if (*s1 == '_')
	31	s1++;
	32	if (*s2 == '_')
	33	s2++;
	34
ede51255	35	for (i = 0; ; i++) {
0c5547d1	36	if ((s1[i] \| s2[i]) == 0)
	37	break;
	38
ede51255	39	if (s1[i] == s2[i])
	40	continue;
	41
0c5547d1	42	if (s1[i] == 0 && s2[i] == '@')
	43	break;
	44	if (s1[i] == '@' && s2[i] == 0)
ede51255	45	break;
	46
	47	return s1[i] - s2[i];
	48	}
	49
	50	return 0;
	51	}
	52
	53	static int cmp_sym_sort(const void p1_, const void p2_)
	54	{
	55	const struct sl_item p1 = p1_, p2 = p2_;
	56	const char s1 = p1->name, s2 = p2->name;
	57	int ret;
	58
	59	ret = cmp_sym(p1_, p2_);
	60	if (ret == 0) {
	61	printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
	62	exit(1);
	63	}
	64	return ret;
	65	}
	66
368deb23	67	void read_list(struct sl_item *sl_in, int cnt, int *alloc,
87ccd363	68	FILE *f, int callsites, int ignore_missing)
ede51255	69	{
	70	struct sl_item sl = sl_in;
	71	int c = *cnt;
	72	char line[256];
	73	char word[256];
ede51255	74
ede51255	75	while (fgets(line, sizeof(line), f) != NULL) {
0c5547d1	76	next_word(word, sizeof(word), line);
0c5547d1	77	if (word[0] == 0 \|\| word[0] == ';' \|\| word[0] == '#')
ede51255	78	continue;
	79
	80	sl[c].name = strdup(word);
368deb23	81	sl[c].callsites = callsites;
87ccd363	82	sl[c].ignore_missing = ignore_missing;
8022df01	83	sl[c].found = 0;
ede51255	84	c++;
	85
	86	if (c >= *alloc) {
	87	alloc = 2;
	88	sl = realloc(sl, alloc sizeof(sl[0]));
	89	my_assert_not(sl, NULL);
8022df01	90	memset(sl + c, 0, (alloc - c) sizeof(sl[0]));
ede51255	91	}
	92	}
	93
	94	*sl_in = sl;
	95	*cnt = c;
	96	}
	97
7aca4698	98	const char sym_use(const struct sl_item sym, int is_rm)
8022df01	99	{
	100	static char buf[256+3];
	101	int ret;
	102
7aca4698	103	ret = snprintf(buf, sizeof(buf), "%s%s",
7aca4698	104	is_rm ? "rm_" : "", sym->name);
8022df01	105	if (ret >= sizeof(buf)) {
	106	printf("truncation detected: '%s'\n", buf);
	107	exit(1);
	108	}
	109
	110	return buf;
	111	}
	112
28023f83	113	#define IS_OR2(w, x, y) (IS(w, x) \|\| IS(w, y))
	114	#define IS_OR3(w, x, y, z) (IS(w, x) \|\| IS(w, y) \|\| IS(w, z))
	115
ede51255	116	int main(int argc, char *argv[])
ede51255	117	{
8022df01	118	struct sl_item symlist, sym, ssym = { NULL, };
368deb23	119	int patch_callsites = 0;
87ccd363	120	int ignore_missing = 0;
ede51255	121	FILE fout, fin, *f;
	122	int symlist_alloc;
	123	int symlist_cnt;
	124	char line[256];
	125	char word[256];
	126	char word2[256];
	127	char word3[256];
	128	char word4[256];
28023f83	129	char word5[256];
28023f83	130	char word6[256];
d4e3b5db	131	char func[256];
de50b98b	132	char p, p2;
8022df01	133	int i;
ede51255	134
368deb23	135	if (argc < 4) {
87ccd363	136	printf("usage:\n%s <asmf_out> <asmf_in> [[-c][-i] <listf>]*>\n",
ede51255	137	argv[0]);
87ccd363	138	printf(" -c - patch callsites\n"
87ccd363	139	" -i - ignore missing syms\n");
ede51255	140	return 1;
	141	}
	142
	143	symlist_alloc = 16;
	144	symlist_cnt = 0;
8022df01	145	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
ede51255	146	my_assert_not(symlist, NULL);
ede51255	147
368deb23	148	for (i = 3; i < argc; i++) {
0c5547d1	149	if (strcmp(argv[i], "-c") == 0) {
368deb23	150	patch_callsites = 1;
	151	continue;
	152	}
87ccd363	153	if (strcmp(argv[i], "-i") == 0) {
	154	ignore_missing = 1;
	155	continue;
	156	}
368deb23	157
	158	f = fopen(argv[i], "r");
	159	my_assert_not(f, NULL);
	160	read_list(&symlist, &symlist_cnt, &symlist_alloc,
87ccd363	161	f, patch_callsites, ignore_missing);
368deb23	162	fclose(f);
ede51255	163
368deb23	164	patch_callsites = 0;
87ccd363	165	ignore_missing = 0;
368deb23	166	}
ede51255	167
	168	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);
	169
8022df01	170	#if 0
	171	printf("symlist:\n");
	172	for (i = 0; i < symlist_cnt; i++)
368deb23	173	printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
8022df01	174	#endif
ede51255	175
	176	fin = fopen(argv[2], "r");
	177	my_assert_not(fin, NULL);
	178
	179	fout = fopen(argv[1], "w");
	180	my_assert_not(fout, NULL);
	181
	182	while (fgets(line, sizeof(line), fin))
	183	{
	184	p = sskip(line);
	185	if (p == 0 \|\| p == ';')
	186	goto pass;
	187
	188	p = sskip(next_word(word, sizeof(word), p));
	189	if (p == 0 \|\| p == ';')
	190	goto pass; // need at least 2 words
	191
	192	p = next_word(word2, sizeof(word2), p);
	193
28023f83	194	if (IS_OR2(word2, "proc", "endp")) {
d4e3b5db	195	if (IS(word2, "proc"))
	196	strcpy(func, word);
	197	else
	198	func[0] = 0;
	199
ede51255	200	ssym.name = word;
	201	sym = bsearch(&ssym, symlist, symlist_cnt,
	202	sizeof(symlist[0]), cmp_sym);
	203	if (sym != NULL) {
8022df01	204	sym->found = 1;
7aca4698	205	fprintf(fout, "%s\t%s%s", sym_use(sym, 1), word2, p);
ede51255	206	continue;
	207	}
	208	}
	209
de15d43b	210	if (IS_OR2(word, "call", "jmp")) {
ede51255	211	ssym.name = word2;
	212	sym = bsearch(&ssym, symlist, symlist_cnt,
	213	sizeof(symlist[0]), cmp_sym);
7aca4698	214	if (sym != NULL) {
8022df01	215	fprintf(fout, "\t\t%s\t%s%s", word,
7aca4698	216	sym_use(sym, sym->callsites \|\| IS(word2, func)), p);
ede51255	217	continue;
	218	}
	219	}
	220
de15d43b	221	if (IS(word, "public")) {
	222	ssym.name = word2;
	223	sym = bsearch(&ssym, symlist, symlist_cnt,
	224	sizeof(symlist[0]), cmp_sym);
	225	if (sym != NULL) {
7aca4698	226	fprintf(fout, "\t\tpublic %s%s", sym_use(sym, 1), p);
de15d43b	227	continue;
	228	}
	229	}
	230
ede51255	231	p = sskip(p);
	232	if (p == 0 \|\| p == ';')
	233	goto pass; // need at least 3 words
	234
	235	p = next_word(word3, sizeof(word3), p);
	236
28023f83	237	// push offset <sym>
092f64e1	238	if (IS(word, "push") && IS(word2, "offset")) {
ede51255	239	ssym.name = word3;
	240	sym = bsearch(&ssym, symlist, symlist_cnt,
	241	sizeof(symlist[0]), cmp_sym);
7aca4698	242	if (sym != NULL) {
	243	fprintf(fout, "\t\t%s %s %s%s", word, word2,
	244	sym_use(sym, sym->callsites \|\| IS(word3, func)), p);
ede51255	245	continue;
	246	}
	247	}
	248
092f64e1	249	// jcc short <sym>
	250	if (word[0] == 'j' && IS(word2, "short") && !IS(word3, "exit")) {
	251	ssym.name = word3;
	252	sym = bsearch(&ssym, symlist, symlist_cnt,
	253	sizeof(symlist[0]), cmp_sym);
	254	if (sym != NULL) {
	255	fprintf(fout, "\t\t%s ", word);
	256	// for conditional "call", don't print 'short'
	257	if (IS(word3, func))
	258	fprintf(fout, "short ");
	259	fprintf(fout, "%s%s",
	260	sym_use(sym, sym->callsites \|\| IS(word3, func)), p);
	261	continue;
	262	}
	263	}
	264
de50b98b	265	// dd offset <sym>
a3047546	266	if (IS(word, "dd")
	267	&& (IS(word2, "offset") \|\| strstr(p, "offset")))
	268	{
de50b98b	269	fprintf(fout, "\t\tdd");
a3047546	270	p = next_word(word, sizeof(word), line);
de50b98b	271	goto offset_loop;
	272	}
	273
ede51255	274	p = sskip(p);
	275	if (p == 0 \|\| p == ';')
	276	goto pass; // need at least 4 words
	277
	278	p = next_word(word4, sizeof(word4), p);
	279
28023f83	280	// <name> dd offset <sym>
a3047546	281	if (IS(word2, "dd")
	282	&& (IS(word3, "offset") \|\| strstr(p, "offset")))
	283	{
de50b98b	284	fprintf(fout, "%s\tdd", word);
a3047546	285	p = next_word(word, sizeof(word), line);
a3047546	286	p = next_word(word, sizeof(word), p);
de50b98b	287	goto offset_loop;
ede51255	288	}
ede51255	289
28023f83	290	// mov <something>, offset <sym>
	291	// jcc <some> ptr <sym>
	292	if ( (IS(word, "mov") && IS(word3, "offset"))
	293	\|\| (word[0] == 'j' && IS(word3, "ptr")) ) {
	294	ssym.name = word4;
	295	sym = bsearch(&ssym, symlist, symlist_cnt,
	296	sizeof(symlist[0]), cmp_sym);
7aca4698	297	if (sym != NULL) {
28023f83	298	fprintf(fout, "\t\t%s\t%s %s %s%s",
28023f83	299	word, word2, word3,
7aca4698	300	sym_use(sym, sym->callsites), p);
28023f83	301	continue;
	302	}
	303	}
	304
	305	p = sskip(p);
	306	if (p == 0 \|\| p == ';')
	307	goto pass; // need at least 5 words
	308
	309	p = next_word(word5, sizeof(word5), p);
	310
	311	p = sskip(p);
	312	if (p == 0 \|\| p == ';')
	313	goto pass; // need at least 6 words
	314
	315	p = next_word(word6, sizeof(word6), p);
	316
	317	// <op> dword ptr <something>, offset <sym>
	318	if ( IS(word2, "dword") && IS(word3, "ptr")
	319	&& IS(word5, "offset") ) {
	320	ssym.name = word6;
	321	sym = bsearch(&ssym, symlist, symlist_cnt,
	322	sizeof(symlist[0]), cmp_sym);
7aca4698	323	if (sym != NULL) {
28023f83	324	fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
7aca4698	325	word, word4, sym_use(sym, sym->callsites), p);
28023f83	326	continue;
	327	}
	328	}
	329
ede51255	330	pass:
ede51255	331	fwrite(line, 1, strlen(line), fout);
de50b98b	332	continue;
	333
	334	offset_loop:
	335	while (1) {
a3047546	336	p2 = next_word(word, sizeof(word), p);
	337	if (word[0] == 0 \|\| word[0] == ';') {
	338	break;
	339	}
	340	if (!IS(word, "offset")) {
	341	// pass through
	342	p2 = strstr(p, "offset");
	343	if (p2 == NULL)
	344	break;
	345	fwrite(p, 1, p2 - p, fout);
	346	p2 = next_word(word, sizeof(word), p2);
	347	}
	348	p = next_word(word, sizeof(word), p2);
de50b98b	349	p2 = strchr(word, ',');
	350	if (p2)
	351	*p2 = 0;
	352
	353	ssym.name = word;
	354	sym = bsearch(&ssym, symlist, symlist_cnt,
	355	sizeof(symlist[0]), cmp_sym);
	356	fprintf(fout, " offset %s%s",
7aca4698	357	(sym != NULL) ? sym_use(sym, sym->callsites) : word,
de50b98b	358	p2 ? "," : "");
de50b98b	359	}
	360	fprintf(fout, "%s", p);
	361	continue;
ede51255	362	}
ede51255	363
8022df01	364	for (i = 0; i < symlist_cnt; i++) {
87ccd363	365	if (!symlist[i].found && !symlist[i].ignore_missing)
8022df01	366	printf("warning: sym '%s' not found\n", symlist[i].name);
	367	}
	368
ede51255	369	fclose(fin);
	370	fclose(fout);
	371
	372	return 0;
	373	}
de50b98b	374
de50b98b	375	// vim:ts=2:shiftwidth=2