crunchgen.c revision 32704 
1/*
2 * Copyright (c) 1994 University of Maryland
3 * All Rights Reserved.
4 *
5 * Permission to use, copy, modify, distribute, and sell this software and its
6 * documentation for any purpose is hereby granted without fee, provided that
7 * the above copyright notice appear in all copies and that both that
8 * copyright notice and this permission notice appear in supporting
9 * documentation, and that the name of U.M. not be used in advertising or
10 * publicity pertaining to distribution of the software without specific,
11 * written prior permission.  U.M. makes no representations about the
12 * suitability of this software for any purpose.  It is provided "as is"
13 * without express or implied warranty.
14 *
15 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
17 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
19 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 *
22 * Author: James da Silva, Systems Design and Analysis Group
23 *			   Computer Science Department
24 *			   University of Maryland at College Park
25 */
26/*
27 * ========================================================================
28 * crunchgen.c
29 *
30 * Generates a Makefile and main C file for a crunched executable,
31 * from specs given in a .conf file.
32 */
33#include <ctype.h>
34#include <err.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <unistd.h>
39
40#include <sys/types.h>
41#include <sys/stat.h>
42#include <sys/param.h>
43
44#define CRUNCH_VERSION	"0.2"
45
46#define MAXLINELEN	16384
47#define MAXFIELDS 	 2048
48
49
50/* internal representation of conf file: */
51
52/* simple lists of strings suffice for most parms */
53
54typedef struct strlst {
55    struct strlst *next;
56    char *str;
57} strlst_t;
58
59/* progs have structure, each field can be set with "special" or calculated */
60
61typedef struct prog {
62    struct prog *next;
63    char *name, *ident;
64    char *srcdir, *objdir;
65    strlst_t *objs, *objpaths;
66    strlst_t *keeplist;
67    strlst_t *links;
68    int goterror;
69} prog_t;
70
71
72/* global state */
73
74strlst_t *srcdirs = NULL;
75strlst_t *libs    = NULL;
76prog_t   *progs   = NULL;
77
78char line[MAXLINELEN];
79
80char confname[MAXPATHLEN], infilename[MAXPATHLEN];
81char outmkname[MAXPATHLEN], outcfname[MAXPATHLEN], execfname[MAXPATHLEN];
82char tempfname[MAXPATHLEN], cachename[MAXPATHLEN], curfilename[MAXPATHLEN];
83int linenum = -1;
84int goterror = 0;
85
86int verbose, readcache;	/* options */
87int reading_cache;
88
89int list_mode;
90
91/* general library routines */
92
93void status(char *str);
94void out_of_memory(void);
95void add_string(strlst_t **listp, char *str);
96int is_dir(char *pathname);
97int is_nonempty_file(char *pathname);
98
99/* helper routines for main() */
100
101void usage(void);
102void parse_conf_file(void);
103void gen_outputs(void);
104
105
106int main(int argc, char **argv)
107{
108    char *p;
109    int optc;
110
111    verbose = 1;
112    readcache = 1;
113    *outmkname = *outcfname = *execfname = '\0';
114
115    while((optc = getopt(argc, argv, "lm:c:e:fq")) != -1) {
116	switch(optc) {
117	case 'f':	readcache = 0; break;
118	case 'q':	verbose = 0; break;
119
120	case 'm':	strcpy(outmkname, optarg); break;
121	case 'c':	strcpy(outcfname, optarg); break;
122	case 'e':	strcpy(execfname, optarg); break;
123	case 'l':	list_mode++; verbose = 0; break;
124
125	case '?':
126	default:	usage();
127	}
128    }
129
130    argc -= optind;
131    argv += optind;
132
133    if(argc != 1) usage();
134
135    /*
136     * generate filenames
137     */
138
139    strcpy(infilename, argv[0]);
140
141    /* confname = `basename infilename .conf` */
142
143    if((p=strrchr(infilename, '/')) != NULL) strcpy(confname, p+1);
144    else strcpy(confname, infilename);
145    if((p=strrchr(confname, '.')) != NULL && !strcmp(p, ".conf")) *p = '\0';
146
147    if(!*outmkname) sprintf(outmkname, "%s.mk", confname);
148    if(!*outcfname) sprintf(outcfname, "%s.c", confname);
149    if(!*execfname) sprintf(execfname, "%s", confname);
150
151    sprintf(cachename, "%s.cache", confname);
152    sprintf(tempfname, ".tmp_%sXXXXXX", confname);
153    if(mktemp(tempfname) == NULL) {
154	perror(tempfname);
155	exit(1);
156    }
157
158    parse_conf_file();
159    if (list_mode)
160	exit(goterror);
161
162    gen_outputs();
163
164    exit(goterror);
165}
166
167
168void usage(void)
169{
170    fprintf(stderr, "%s\n%s\n",
171		"usage: crunchgen [-fq] [-m <makefile>] [-c <c file>]",
172		"                 [-e <exec file>] <conffile>");
173    exit(1);
174}
175
176
177/*
178 * ========================================================================
179 * parse_conf_file subsystem
180 *
181 */
182
183/* helper routines for parse_conf_file */
184
185void parse_one_file(char *filename);
186void parse_line(char *line, int *fc, char **fv, int nf);
187void add_srcdirs(int argc, char **argv);
188void add_progs(int argc, char **argv);
189void add_link(int argc, char **argv);
190void add_libs(int argc, char **argv);
191void add_special(int argc, char **argv);
192
193prog_t *find_prog(char *str);
194void add_prog(char *progname);
195
196
197void parse_conf_file(void)
198{
199    if(!is_nonempty_file(infilename))
200		errx(1, "fatal: input file \"%s\" not found", infilename);
201    parse_one_file(infilename);
202    if(readcache && is_nonempty_file(cachename)) {
203	reading_cache = 1;
204	parse_one_file(cachename);
205    }
206}
207
208
209void parse_one_file(char *filename)
210{
211    char *fieldv[MAXFIELDS];
212    int fieldc;
213    void (*f)(int c, char **v);
214    FILE *cf;
215
216    sprintf(line, "reading %s", filename);
217    status(line);
218    strcpy(curfilename, filename);
219
220    if((cf = fopen(curfilename, "r")) == NULL) {
221	warn("%s", curfilename);
222	goterror = 1;
223	return;
224    }
225
226    linenum = 0;
227    while(fgets(line, MAXLINELEN, cf) != NULL) {
228	linenum++;
229	parse_line(line, &fieldc, fieldv, MAXFIELDS);
230	if(fieldc < 1) continue;
231	if(!strcmp(fieldv[0], "srcdirs"))	f = add_srcdirs;
232	else if(!strcmp(fieldv[0], "progs"))    f = add_progs;
233	else if(!strcmp(fieldv[0], "ln"))	f = add_link;
234	else if(!strcmp(fieldv[0], "libs"))	f = add_libs;
235	else if(!strcmp(fieldv[0], "special"))	f = add_special;
236	else {
237	    warnx("%s:%d: skipping unknown command `%s'",
238		    curfilename, linenum, fieldv[0]);
239	    goterror = 1;
240	    continue;
241	}
242	if(fieldc < 2) {
243	    warnx("%s:%d: %s command needs at least 1 argument, skipping",
244		    curfilename, linenum, fieldv[0]);
245	    goterror = 1;
246	    continue;
247	}
248	f(fieldc, fieldv);
249    }
250
251    if(ferror(cf)) {
252	warn("%s", curfilename);
253	goterror = 1;
254    }
255    fclose(cf);
256}
257
258
259void parse_line(char *line, int *fc, char **fv, int nf)
260{
261    char *p;
262
263    p = line;
264    *fc = 0;
265    while(1) {
266	while(isspace(*p)) p++;
267	if(*p == '\0' || *p == '#') break;
268
269	if(*fc < nf) fv[(*fc)++] = p;
270	while(*p && !isspace(*p) && *p != '#') p++;
271	if(*p == '\0' || *p == '#') break;
272	*p++ = '\0';
273    }
274    if(*p) *p = '\0';		/* needed for '#' case */
275}
276
277
278void add_srcdirs(int argc, char **argv)
279{
280    int i;
281
282    for(i=1;i<argc;i++) {
283	if(is_dir(argv[i]))
284	    add_string(&srcdirs, argv[i]);
285	else {
286	    warnx("%s:%d: `%s' is not a directory, skipping it",
287		    curfilename, linenum, argv[i]);
288	    goterror = 1;
289	}
290    }
291}
292
293
294void add_progs(int argc, char **argv)
295{
296    int i;
297
298    for(i=1;i<argc;i++)
299	add_prog(argv[i]);
300}
301
302
303void add_prog(char *progname)
304{
305    prog_t *p1, *p2;
306
307    /* add to end, but be smart about dups */
308
309    for(p1 = NULL, p2 = progs; p2 != NULL; p1 = p2, p2 = p2->next)
310	if(!strcmp(p2->name, progname)) return;
311
312    p2 = malloc(sizeof(prog_t));
313    if(p2) {
314	memset(p2, 0, sizeof(prog_t));
315	p2->name = strdup(progname);
316    }
317    if(!p2 || !p2->name)
318	out_of_memory();
319
320    p2->next = NULL;
321    if(p1 == NULL) progs = p2;
322    else p1->next = p2;
323
324    p2->ident = p2->srcdir = p2->objdir = NULL;
325    p2->links = p2->objs = p2->keeplist = NULL;
326    p2->goterror = 0;
327    if (list_mode)
328        printf("%s\n",progname);
329}
330
331
332void add_link(int argc, char **argv)
333{
334    int i;
335    prog_t *p = find_prog(argv[1]);
336
337    if(p == NULL) {
338	warnx("%s:%d: no prog %s previously declared, skipping link",
339		curfilename, linenum, argv[1]);
340	goterror = 1;
341	return;
342    }
343    for(i=2;i<argc;i++) {
344	if (list_mode)
345		printf("%s\n",argv[i]);
346	add_string(&p->links, argv[i]);
347    }
348}
349
350
351void add_libs(int argc, char **argv)
352{
353    int i;
354
355    for(i=1;i<argc;i++)
356	add_string(&libs, argv[i]);
357}
358
359
360void add_special(int argc, char **argv)
361{
362    int i;
363    prog_t *p = find_prog(argv[1]);
364
365    if(p == NULL) {
366	if(reading_cache) return;
367	warnx("%s:%d: no prog %s previously declared, skipping special",
368		curfilename, linenum, argv[1]);
369	goterror = 1;
370	return;
371    }
372
373    if(!strcmp(argv[2], "ident")) {
374	if(argc != 4) goto argcount;
375	if((p->ident = strdup(argv[3])) == NULL)
376	    out_of_memory();
377    }
378    else if(!strcmp(argv[2], "srcdir")) {
379	if(argc != 4) goto argcount;
380	if((p->srcdir = strdup(argv[3])) == NULL)
381	    out_of_memory();
382    }
383    else if(!strcmp(argv[2], "objdir")) {
384	if(argc != 4) goto argcount;
385	if((p->objdir = strdup(argv[3])) == NULL)
386	    out_of_memory();
387    }
388    else if(!strcmp(argv[2], "objs")) {
389	p->objs = NULL;
390	for(i=3;i<argc;i++)
391	    add_string(&p->objs, argv[i]);
392    }
393    else if(!strcmp(argv[2], "objpaths")) {
394	p->objpaths = NULL;
395	for(i=3;i<argc;i++)
396	    add_string(&p->objpaths, argv[i]);
397    }
398    else if(!strcmp(argv[2], "keep")) {
399	p->keeplist = NULL;
400	for(i=3;i<argc;i++)
401	    add_string(&p->keeplist, argv[i]);
402    }
403    else {
404	warnx("%s:%d: bad parameter name `%s', skipping line",
405		curfilename, linenum, argv[2]);
406	goterror = 1;
407    }
408    return;
409
410
411 argcount:
412    warnx("%s:%d: too %s arguments, expected \"special %s %s <string>\"",
413	    curfilename, linenum, argc < 4? "few" : "many", argv[1], argv[2]);
414    goterror = 1;
415}
416
417
418prog_t *find_prog(char *str)
419{
420    prog_t *p;
421
422    for(p = progs; p != NULL; p = p->next)
423	if(!strcmp(p->name, str)) return p;
424
425    return NULL;
426}
427
428
429/*
430 * ========================================================================
431 * gen_outputs subsystem
432 *
433 */
434
435/* helper subroutines */
436
437void remove_error_progs(void);
438void fillin_program(prog_t *p);
439void gen_specials_cache(void);
440void gen_output_makefile(void);
441void gen_output_cfile(void);
442
443void fillin_program_objs(prog_t *p, char *path);
444void top_makefile_rules(FILE *outmk);
445void prog_makefile_rules(FILE *outmk, prog_t *p);
446void output_strlst(FILE *outf, strlst_t *lst);
447char *genident(char *str);
448char *dir_search(char *progname);
449
450
451void gen_outputs(void)
452{
453    prog_t *p;
454
455    for(p = progs; p != NULL; p = p->next)
456	fillin_program(p);
457
458    remove_error_progs();
459    gen_specials_cache();
460    gen_output_cfile();
461    gen_output_makefile();
462    status("");
463    fprintf(stderr,
464	    "Run \"make -f %s objs exe\" to build crunched binary.\n",
465	    outmkname);
466}
467
468
469void fillin_program(prog_t *p)
470{
471    char path[MAXPATHLEN];
472    char *srcparent;
473    strlst_t *s;
474
475    sprintf(line, "filling in parms for %s", p->name);
476    status(line);
477
478    if(!p->ident)
479	p->ident = genident(p->name);
480    if(!p->srcdir) {
481	srcparent = dir_search(p->name);
482	if(srcparent)
483	    sprintf(path, "%s/%s", srcparent, p->name);
484	if(is_dir(path))
485	    p->srcdir = strdup(path);
486    }
487    if(!p->objdir && p->srcdir) {
488	FILE *f;
489
490	sprintf(path, "cd %s && echo -n /usr/obj`/bin/pwd`", p->srcdir);
491        p->objdir = p->srcdir;
492	f = popen(path,"r");
493	if (f) {
494	    fgets(path,sizeof path, f);
495	    if (!pclose(f)) {
496		if(is_dir(path))
497		    p->objdir = strdup(path);
498	    }
499	}
500    }
501
502    if(p->srcdir) sprintf(path, "%s/Makefile", p->srcdir);
503    if(!p->objs && p->srcdir && is_nonempty_file(path))
504	fillin_program_objs(p, path);
505
506    if(!p->objpaths && p->objdir && p->objs)
507	for(s = p->objs; s != NULL; s = s->next) {
508	    sprintf(line, "%s/%s", p->objdir, s->str);
509	    add_string(&p->objpaths, line);
510	}
511
512    if(!p->srcdir && verbose)
513	warnx("%s: %s: warning: could not find source directory",
514		infilename, p->name);
515    if(!p->objs && verbose)
516	warnx("%s: %s: warning: could not find any .o files",
517		infilename, p->name);
518
519    if(!p->objpaths) {
520	warnx("%s: %s: error: no objpaths specified or calculated",
521		infilename, p->name);
522	p->goterror = goterror = 1;
523    }
524}
525
526void fillin_program_objs(prog_t *p, char *path)
527{
528    char *obj, *cp;
529    int rc;
530    FILE *f;
531
532    /* discover the objs from the srcdir Makefile */
533
534    if((f = fopen(tempfname, "w")) == NULL) {
535	warn("%s", tempfname);
536	goterror = 1;
537	return;
538    }
539
540    fprintf(f, ".include \"%s\"\n", path);
541    fprintf(f, ".if defined(PROG) && !defined(OBJS)\n");
542    fprintf(f, "OBJS=${PROG}.o\n");
543    fprintf(f, ".endif\n");
544    fprintf(f, "crunchgen_objs:\n\t@echo 'OBJS= '${OBJS}\n");
545    fclose(f);
546
547    sprintf(line, "make -f %s crunchgen_objs 2>&1", tempfname);
548    if((f = popen(line, "r")) == NULL) {
549	warn("submake pipe");
550	goterror = 1;
551	return;
552    }
553
554    while(fgets(line, MAXLINELEN, f)) {
555	if(strncmp(line, "OBJS= ", 6)) {
556	    warnx("make error: %s", line);
557	    goterror = 1;
558	    continue;
559	}
560	cp = line + 6;
561	while(isspace(*cp)) cp++;
562	while(*cp) {
563	    obj = cp;
564	    while(*cp && !isspace(*cp)) cp++;
565	    if(*cp) *cp++ = '\0';
566	    add_string(&p->objs, obj);
567	    while(isspace(*cp)) cp++;
568	}
569    }
570    if((rc=pclose(f)) != 0) {
571	warnx("make error: make returned %d", rc);
572	goterror = 1;
573    }
574    unlink(tempfname);
575}
576
577void remove_error_progs(void)
578{
579    prog_t *p1, *p2;
580
581    p1 = NULL; p2 = progs;
582    while(p2 != NULL) {
583	if(!p2->goterror)
584	    p1 = p2, p2 = p2->next;
585	else {
586	    /* delete it from linked list */
587	    warnx("%s: %s: ignoring program because of errors",
588		    infilename, p2->name);
589	    if(p1) p1->next = p2->next;
590	    else progs = p2->next;
591	    p2 = p2->next;
592	}
593    }
594}
595
596void gen_specials_cache(void)
597{
598    FILE *cachef;
599    prog_t *p;
600
601    sprintf(line, "generating %s", cachename);
602    status(line);
603
604    if((cachef = fopen(cachename, "w")) == NULL) {
605	warn("%s", cachename);
606	goterror = 1;
607	return;
608    }
609
610    fprintf(cachef, "# %s - parm cache generated from %s by crunchgen %s\n\n",
611	    cachename, infilename, CRUNCH_VERSION);
612
613    for(p = progs; p != NULL; p = p->next) {
614	fprintf(cachef, "\n");
615	if(p->srcdir)
616	    fprintf(cachef, "special %s srcdir %s\n", p->name, p->srcdir);
617	if(p->objdir)
618	    fprintf(cachef, "special %s objdir %s\n", p->name, p->objdir);
619	if(p->objs) {
620	    fprintf(cachef, "special %s objs", p->name);
621	    output_strlst(cachef, p->objs);
622	}
623	fprintf(cachef, "special %s objpaths", p->name);
624	output_strlst(cachef, p->objpaths);
625    }
626    fclose(cachef);
627}
628
629
630void gen_output_makefile(void)
631{
632    prog_t *p;
633    FILE *outmk;
634
635    sprintf(line, "generating %s", outmkname);
636    status(line);
637
638    if((outmk = fopen(outmkname, "w")) == NULL) {
639	warn("%s", outmkname);
640	goterror = 1;
641	return;
642    }
643
644    fprintf(outmk, "# %s - generated from %s by crunchgen %s\n\n",
645	    outmkname, infilename, CRUNCH_VERSION);
646
647    top_makefile_rules(outmk);
648
649    for(p = progs; p != NULL; p = p->next)
650	prog_makefile_rules(outmk, p);
651
652    fprintf(outmk, "\n# ========\n");
653    fclose(outmk);
654}
655
656
657void gen_output_cfile(void)
658{
659    extern char *crunched_skel[];
660    char **cp;
661    FILE *outcf;
662    prog_t *p;
663    strlst_t *s;
664
665    sprintf(line, "generating %s", outcfname);
666    status(line);
667
668    if((outcf = fopen(outcfname, "w")) == NULL) {
669	warn("%s", outcfname);
670	goterror = 1;
671	return;
672    }
673
674    fprintf(outcf,
675	  "/* %s - generated from %s by crunchgen %s */\n",
676	    outcfname, infilename, CRUNCH_VERSION);
677
678    fprintf(outcf, "#define EXECNAME \"%s\"\n", execfname);
679    for(cp = crunched_skel; *cp != NULL; cp++)
680	fprintf(outcf, "%s\n", *cp);
681
682    for(p = progs; p != NULL; p = p->next)
683	fprintf(outcf, "extern int _crunched_%s_stub();\n", p->ident);
684
685    fprintf(outcf, "\nstruct stub entry_points[] = {\n");
686    for(p = progs; p != NULL; p = p->next) {
687	fprintf(outcf, "\t{ \"%s\", _crunched_%s_stub },\n",
688		p->name, p->ident);
689	for(s = p->links; s != NULL; s = s->next)
690	    fprintf(outcf, "\t{ \"%s\", _crunched_%s_stub },\n",
691		    s->str, p->ident);
692    }
693
694    fprintf(outcf, "\t{ EXECNAME, crunched_main },\n");
695    fprintf(outcf, "\t{ NULL, NULL }\n};\n");
696    fclose(outcf);
697}
698
699
700char *genident(char *str)
701{
702    char *n,*s,*d;
703
704    /*
705     * generates a Makefile/C identifier from a program name, mapping '-' to
706     * '_' and ignoring all other non-identifier characters.  This leads to
707     * programs named "foo.bar" and "foobar" to map to the same identifier.
708     */
709
710    if((n = strdup(str)) == NULL)
711	return NULL;
712    for(d = s = n; *s != '\0'; s++) {
713	if(*s == '-') *d++ = '_';
714	else if(*s == '_' || isalnum(*s)) *d++ = *s;
715    }
716    *d = '\0';
717    return n;
718}
719
720
721char *dir_search(char *progname)
722{
723    char path[MAXPATHLEN];
724    strlst_t *dir;
725
726    for(dir=srcdirs; dir != NULL; dir=dir->next) {
727	sprintf(path, "%s/%s", dir->str, progname);
728	if(is_dir(path)) return dir->str;
729    }
730    return NULL;
731}
732
733
734void top_makefile_rules(FILE *outmk)
735{
736    prog_t *p;
737
738    fprintf(outmk, "LIBS=");
739    output_strlst(outmk, libs);
740
741    fprintf(outmk, "CRUNCHED_OBJS=");
742    for(p = progs; p != NULL; p = p->next)
743	fprintf(outmk, " %s.lo", p->name);
744    fprintf(outmk, "\n");
745
746    fprintf(outmk, "SUBMAKE_TARGETS=");
747    for(p = progs; p != NULL; p = p->next)
748	fprintf(outmk, " %s_make", p->ident);
749    fprintf(outmk, "\nSUBCLEAN_TARGETS=");
750    for(p = progs; p != NULL; p = p->next)
751	fprintf(outmk, " %s_clean", p->ident);
752    fprintf(outmk, "\n\n");
753
754    fprintf(outmk, "%s: %s.o $(CRUNCHED_OBJS)\n",
755	    execfname, execfname);
756    fprintf(outmk, "\t$(CC) -static -o %s %s.o $(CRUNCHED_OBJS) $(LIBS)\n",
757	    execfname, execfname);
758    fprintf(outmk, "\tstrip %s\n", execfname);
759    fprintf(outmk, "all: objs exe\nobjs: $(SUBMAKE_TARGETS)\n");
760    fprintf(outmk, "exe: %s\n", execfname);
761    fprintf(outmk, "realclean: clean subclean\n");
762    fprintf(outmk, "clean:\n\trm -f %s *.lo *.o *_stub.c\n",
763	    execfname);
764    fprintf(outmk, "subclean: $(SUBCLEAN_TARGETS)\n");
765}
766
767
768void prog_makefile_rules(FILE *outmk, prog_t *p)
769{
770    strlst_t *lst;
771
772    fprintf(outmk, "\n# -------- %s\n\n", p->name);
773
774    if(p->srcdir && p->objs) {
775	fprintf(outmk, "%s_SRCDIR=%s\n", p->ident, p->srcdir);
776	fprintf(outmk, "%s_OBJS=", p->ident);
777	output_strlst(outmk, p->objs);
778	fprintf(outmk, "%s_make:\n", p->ident);
779	fprintf(outmk, "\t(cd $(%s_SRCDIR) && make depend && make $(%s_OBJS))\n",
780		p->ident, p->ident);
781	fprintf(outmk, "%s_clean:\n", p->ident);
782	fprintf(outmk, "\t(cd $(%s_SRCDIR) && make clean)\n\n", p->ident);
783    }
784    else
785	fprintf(outmk, "%s_make:\n\t@echo \"** cannot make objs for %s\"\n\n",
786		p->ident, p->name);
787
788    fprintf(outmk,   "%s_OBJPATHS=", p->ident);
789    output_strlst(outmk, p->objpaths);
790
791    fprintf(outmk, "%s_stub.c:\n", p->name);
792    fprintf(outmk, "\techo \""
793	           "int _crunched_%s_stub(int argc, char **argv, char **envp)"
794	           "{return main(argc,argv,envp);}\" >%s_stub.c\n",
795	    p->ident, p->name);
796    fprintf(outmk, "%s.lo: %s_stub.o $(%s_OBJPATHS)\n",
797	    p->name, p->name, p->ident);
798    fprintf(outmk, "\tld -dc -r -o %s.lo %s_stub.o $(%s_OBJPATHS)\n",
799	    p->name, p->name, p->ident);
800    fprintf(outmk, "\tcrunchide -k __crunched_%s_stub ", p->ident);
801    for(lst = p->keeplist; lst != NULL; lst = lst->next)
802      fprintf(outmk, "-k _%s ", lst->str);
803    fprintf(outmk, "%s.lo\n", p->name);
804}
805
806void output_strlst(FILE *outf, strlst_t *lst)
807{
808    for(; lst != NULL; lst = lst->next)
809	fprintf(outf, " %s", lst->str);
810    fprintf(outf, "\n");
811}
812
813
814/*
815 * ========================================================================
816 * general library routines
817 *
818 */
819
820void status(char *str)
821{
822    static int lastlen = 0;
823    int len, spaces;
824
825    if(!verbose) return;
826
827    len = strlen(str);
828    spaces = lastlen - len;
829    if(spaces < 1) spaces = 1;
830
831    fprintf(stderr, " [%s]%*.*s\r", str, spaces, spaces, " ");
832    fflush(stderr);
833    lastlen = len;
834}
835
836
837void out_of_memory(void)
838{
839    errx(1, "%s: %d: out of memory, stopping", infilename, linenum);
840}
841
842
843void add_string(strlst_t **listp, char *str)
844{
845    strlst_t *p1, *p2;
846
847    /* add to end, but be smart about dups */
848
849    for(p1 = NULL, p2 = *listp; p2 != NULL; p1 = p2, p2 = p2->next)
850	if(!strcmp(p2->str, str)) return;
851
852    p2 = malloc(sizeof(strlst_t));
853    if(p2) {
854	memset(p2, 0, sizeof(strlst_t));
855	p2->str = strdup(str);
856    }
857    if(!p2 || !p2->str)
858	out_of_memory();
859
860    p2->next = NULL;
861    if(p1 == NULL) *listp = p2;
862    else p1->next = p2;
863}
864
865
866int is_dir(char *pathname)
867{
868    struct stat buf;
869
870    if(stat(pathname, &buf) == -1)
871	return 0;
872    return S_ISDIR(buf.st_mode);
873}
874
875int is_nonempty_file(char *pathname)
876{
877    struct stat buf;
878
879    if(stat(pathname, &buf) == -1)
880	return 0;
881
882    return S_ISREG(buf.st_mode) && buf.st_size > 0;
883}
884