crunchgen.c revision 17430
11722Sjkh/* 21722Sjkh * Copyright (c) 1994 University of Maryland 31722Sjkh * All Rights Reserved. 41722Sjkh * 51722Sjkh * Permission to use, copy, modify, distribute, and sell this software and its 61722Sjkh * documentation for any purpose is hereby granted without fee, provided that 71722Sjkh * the above copyright notice appear in all copies and that both that 81722Sjkh * copyright notice and this permission notice appear in supporting 91722Sjkh * documentation, and that the name of U.M. not be used in advertising or 101722Sjkh * publicity pertaining to distribution of the software without specific, 111722Sjkh * written prior permission. U.M. makes no representations about the 121722Sjkh * suitability of this software for any purpose. It is provided "as is" 131722Sjkh * without express or implied warranty. 141722Sjkh * 151722Sjkh * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL 161722Sjkh * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M. 171722Sjkh * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 181722Sjkh * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 191722Sjkh * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 201722Sjkh * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 211722Sjkh * 221722Sjkh * Author: James da Silva, Systems Design and Analysis Group 231722Sjkh * Computer Science Department 241722Sjkh * University of Maryland at College Park 251722Sjkh */ 261722Sjkh/* 271722Sjkh * ======================================================================== 281722Sjkh * crunchgen.c 291722Sjkh * 301722Sjkh * Generates a Makefile and main C file for a crunched executable, 318857Srgrimes * from specs given in a .conf file. 321722Sjkh */ 331722Sjkh#include <stdlib.h> 341722Sjkh#include <unistd.h> 351722Sjkh#include <stdio.h> 361722Sjkh#include <ctype.h> 371722Sjkh#include <string.h> 381722Sjkh 391722Sjkh#include <sys/types.h> 401722Sjkh#include <sys/stat.h> 411722Sjkh#include <sys/param.h> 421722Sjkh 431722Sjkh#define CRUNCH_VERSION "0.2" 441722Sjkh 451722Sjkh#define MAXLINELEN 16384 461722Sjkh#define MAXFIELDS 2048 471722Sjkh 481722Sjkh 491722Sjkh/* internal representation of conf file: */ 501722Sjkh 511722Sjkh/* simple lists of strings suffice for most parms */ 521722Sjkh 531722Sjkhtypedef struct strlst { 541722Sjkh struct strlst *next; 551722Sjkh char *str; 561722Sjkh} strlst_t; 571722Sjkh 581722Sjkh/* progs have structure, each field can be set with "special" or calculated */ 591722Sjkh 601722Sjkhtypedef struct prog { 611722Sjkh struct prog *next; 621722Sjkh char *name, *ident; 631722Sjkh char *srcdir, *objdir; 641722Sjkh strlst_t *objs, *objpaths; 651722Sjkh strlst_t *links; 661722Sjkh int goterror; 671722Sjkh} prog_t; 681722Sjkh 691722Sjkh 701722Sjkh/* global state */ 711722Sjkh 721722Sjkhstrlst_t *srcdirs = NULL; 731722Sjkhstrlst_t *libs = NULL; 741722Sjkhprog_t *progs = NULL; 751722Sjkh 761722Sjkhchar line[MAXLINELEN]; 771722Sjkh 781722Sjkhchar confname[MAXPATHLEN], infilename[MAXPATHLEN]; 791722Sjkhchar outmkname[MAXPATHLEN], outcfname[MAXPATHLEN], execfname[MAXPATHLEN]; 801722Sjkhchar tempfname[MAXPATHLEN], cachename[MAXPATHLEN], curfilename[MAXPATHLEN]; 811722Sjkhint linenum = -1; 821722Sjkhint goterror = 0; 831722Sjkh 841722Sjkhchar *pname = "crunchgen"; 851722Sjkh 861722Sjkhint verbose, readcache; /* options */ 871722Sjkhint reading_cache; 881722Sjkh 896696Sphkint list_mode; 906696Sphk 911722Sjkh/* general library routines */ 921722Sjkh 931722Sjkhvoid status(char *str); 941722Sjkhvoid out_of_memory(void); 951722Sjkhvoid add_string(strlst_t **listp, char *str); 961722Sjkhint is_dir(char *pathname); 971722Sjkhint is_nonempty_file(char *pathname); 981722Sjkh 991722Sjkh/* helper routines for main() */ 1001722Sjkh 1018857Srgrimesvoid usage(void); 1021722Sjkhvoid parse_conf_file(void); 1031722Sjkhvoid gen_outputs(void); 1041722Sjkh 1051722Sjkh 1061722Sjkhint main(int argc, char **argv) 1071722Sjkh{ 1081722Sjkh char *p; 1091722Sjkh int optc; 1101722Sjkh extern int optind; 1111722Sjkh extern char *optarg; 1121722Sjkh 1131722Sjkh verbose = 1; 1141722Sjkh readcache = 1; 1151722Sjkh *outmkname = *outcfname = *execfname = '\0'; 1168857Srgrimes 1171722Sjkh if(argc > 0) pname = argv[0]; 1181722Sjkh 1196696Sphk while((optc = getopt(argc, argv, "lm:c:e:fq")) != -1) { 1201722Sjkh switch(optc) { 1211722Sjkh case 'f': readcache = 0; break; 1221722Sjkh case 'q': verbose = 0; break; 1231722Sjkh 1241722Sjkh case 'm': strcpy(outmkname, optarg); break; 1251722Sjkh case 'c': strcpy(outcfname, optarg); break; 1261722Sjkh case 'e': strcpy(execfname, optarg); break; 1276696Sphk case 'l': list_mode++; verbose = 0; break; 1281722Sjkh 1291722Sjkh case '?': 1301722Sjkh default: usage(); 1311722Sjkh } 1321722Sjkh } 1331722Sjkh 1341722Sjkh argc -= optind; 1351722Sjkh argv += optind; 1361722Sjkh 1371722Sjkh if(argc != 1) usage(); 1381722Sjkh 1398857Srgrimes /* 1401722Sjkh * generate filenames 1411722Sjkh */ 1421722Sjkh 1431722Sjkh strcpy(infilename, argv[0]); 1441722Sjkh 1451722Sjkh /* confname = `basename infilename .conf` */ 1461722Sjkh 1471722Sjkh if((p=strrchr(infilename, '/')) != NULL) strcpy(confname, p+1); 1481722Sjkh else strcpy(confname, infilename); 1491722Sjkh if((p=strrchr(confname, '.')) != NULL && !strcmp(p, ".conf")) *p = '\0'; 1501722Sjkh 1511722Sjkh if(!*outmkname) sprintf(outmkname, "%s.mk", confname); 1521722Sjkh if(!*outcfname) sprintf(outcfname, "%s.c", confname); 1531722Sjkh if(!*execfname) sprintf(execfname, "%s", confname); 1541722Sjkh 1551722Sjkh sprintf(cachename, "%s.cache", confname); 1561722Sjkh sprintf(tempfname, ".tmp_%sXXXXXX", confname); 1571722Sjkh if(mktemp(tempfname) == NULL) { 1581722Sjkh perror(tempfname); 1591722Sjkh exit(1); 1601722Sjkh } 1611722Sjkh 1621722Sjkh parse_conf_file(); 1636696Sphk if (list_mode) 1646696Sphk exit(goterror); 1656696Sphk 1661722Sjkh gen_outputs(); 1671722Sjkh 1681722Sjkh exit(goterror); 1691722Sjkh} 1701722Sjkh 1711722Sjkh 1721722Sjkhvoid usage(void) 1731722Sjkh{ 1748857Srgrimes fprintf(stderr, 1751722Sjkh "%s [-fq] [-m <makefile>] [-c <c file>] [-e <exec file>] <conffile>\n", 1761722Sjkh pname); 1771722Sjkh exit(1); 1781722Sjkh} 1791722Sjkh 1801722Sjkh 1811722Sjkh/* 1821722Sjkh * ======================================================================== 1831722Sjkh * parse_conf_file subsystem 1841722Sjkh * 1851722Sjkh */ 1861722Sjkh 1871722Sjkh/* helper routines for parse_conf_file */ 1881722Sjkh 1891722Sjkhvoid parse_one_file(char *filename); 1908857Srgrimesvoid parse_line(char *line, int *fc, char **fv, int nf); 1911722Sjkhvoid add_srcdirs(int argc, char **argv); 1921722Sjkhvoid add_progs(int argc, char **argv); 1931722Sjkhvoid add_link(int argc, char **argv); 1941722Sjkhvoid add_libs(int argc, char **argv); 1951722Sjkhvoid add_special(int argc, char **argv); 1961722Sjkh 1971722Sjkhprog_t *find_prog(char *str); 1981722Sjkhvoid add_prog(char *progname); 1991722Sjkh 2001722Sjkh 2011722Sjkhvoid parse_conf_file(void) 2021722Sjkh{ 2031722Sjkh if(!is_nonempty_file(infilename)) { 2041722Sjkh fprintf(stderr, "%s: fatal: input file \"%s\" not found.\n", 2051722Sjkh pname, infilename); 2061722Sjkh exit(1); 2071722Sjkh } 2081722Sjkh parse_one_file(infilename); 2091722Sjkh if(readcache && is_nonempty_file(cachename)) { 2101722Sjkh reading_cache = 1; 2111722Sjkh parse_one_file(cachename); 2121722Sjkh } 2131722Sjkh} 2141722Sjkh 2151722Sjkh 2161722Sjkhvoid parse_one_file(char *filename) 2171722Sjkh{ 2181722Sjkh char *fieldv[MAXFIELDS]; 2191722Sjkh int fieldc; 2201722Sjkh void (*f)(int c, char **v); 2211722Sjkh FILE *cf; 2221722Sjkh 2231722Sjkh sprintf(line, "reading %s", filename); 2241722Sjkh status(line); 2251722Sjkh strcpy(curfilename, filename); 2261722Sjkh 2271722Sjkh if((cf = fopen(curfilename, "r")) == NULL) { 2281722Sjkh perror(curfilename); 2291722Sjkh goterror = 1; 2301722Sjkh return; 2311722Sjkh } 2321722Sjkh 2331722Sjkh linenum = 0; 2341722Sjkh while(fgets(line, MAXLINELEN, cf) != NULL) { 2351722Sjkh linenum++; 2361722Sjkh parse_line(line, &fieldc, fieldv, MAXFIELDS); 2371722Sjkh if(fieldc < 1) continue; 2381722Sjkh if(!strcmp(fieldv[0], "srcdirs")) f = add_srcdirs; 2391722Sjkh else if(!strcmp(fieldv[0], "progs")) f = add_progs; 2401722Sjkh else if(!strcmp(fieldv[0], "ln")) f = add_link; 2411722Sjkh else if(!strcmp(fieldv[0], "libs")) f = add_libs; 2421722Sjkh else if(!strcmp(fieldv[0], "special")) f = add_special; 2431722Sjkh else { 2441722Sjkh fprintf(stderr, "%s:%d: skipping unknown command `%s'.\n", 2451722Sjkh curfilename, linenum, fieldv[0]); 2461722Sjkh goterror = 1; 2471722Sjkh continue; 2481722Sjkh } 2491722Sjkh if(fieldc < 2) { 2508857Srgrimes fprintf(stderr, 2511722Sjkh "%s:%d: %s command needs at least 1 argument, skipping.\n", 2521722Sjkh curfilename, linenum, fieldv[0]); 2531722Sjkh goterror = 1; 2541722Sjkh continue; 2551722Sjkh } 2561722Sjkh f(fieldc, fieldv); 2571722Sjkh } 2581722Sjkh 2591722Sjkh if(ferror(cf)) { 2601722Sjkh perror(curfilename); 2611722Sjkh goterror = 1; 2621722Sjkh } 2631722Sjkh fclose(cf); 2641722Sjkh} 2651722Sjkh 2661722Sjkh 2671722Sjkhvoid parse_line(char *line, int *fc, char **fv, int nf) 2681722Sjkh{ 2691722Sjkh char *p; 2701722Sjkh 2711722Sjkh p = line; 2721722Sjkh *fc = 0; 2731722Sjkh while(1) { 2741722Sjkh while(isspace(*p)) p++; 2751722Sjkh if(*p == '\0' || *p == '#') break; 2761722Sjkh 2771722Sjkh if(*fc < nf) fv[(*fc)++] = p; 2781722Sjkh while(*p && !isspace(*p) && *p != '#') p++; 2791722Sjkh if(*p == '\0' || *p == '#') break; 2801722Sjkh *p++ = '\0'; 2811722Sjkh } 2821722Sjkh if(*p) *p = '\0'; /* needed for '#' case */ 2831722Sjkh} 2841722Sjkh 2851722Sjkh 2861722Sjkhvoid add_srcdirs(int argc, char **argv) 2871722Sjkh{ 2881722Sjkh int i; 2891722Sjkh 2901722Sjkh for(i=1;i<argc;i++) { 2911722Sjkh if(is_dir(argv[i])) 2921722Sjkh add_string(&srcdirs, argv[i]); 2931722Sjkh else { 2948857Srgrimes fprintf(stderr, "%s:%d: `%s' is not a directory, skipping it.\n", 2951722Sjkh curfilename, linenum, argv[i]); 2961722Sjkh goterror = 1; 2971722Sjkh } 2981722Sjkh } 2991722Sjkh} 3001722Sjkh 3011722Sjkh 3021722Sjkhvoid add_progs(int argc, char **argv) 3031722Sjkh{ 3041722Sjkh int i; 3051722Sjkh 3061722Sjkh for(i=1;i<argc;i++) 3071722Sjkh add_prog(argv[i]); 3081722Sjkh} 3091722Sjkh 3101722Sjkh 3111722Sjkhvoid add_prog(char *progname) 3121722Sjkh{ 3131722Sjkh prog_t *p1, *p2; 3141722Sjkh 3151722Sjkh /* add to end, but be smart about dups */ 3161722Sjkh 3171722Sjkh for(p1 = NULL, p2 = progs; p2 != NULL; p1 = p2, p2 = p2->next) 3181722Sjkh if(!strcmp(p2->name, progname)) return; 3191722Sjkh 3201722Sjkh p2 = malloc(sizeof(prog_t)); 3211722Sjkh if(p2) p2->name = strdup(progname); 3228857Srgrimes if(!p2 || !p2->name) 3231722Sjkh out_of_memory(); 3241722Sjkh 3251722Sjkh p2->next = NULL; 3261722Sjkh if(p1 == NULL) progs = p2; 3271722Sjkh else p1->next = p2; 3281722Sjkh 3291722Sjkh p2->ident = p2->srcdir = p2->objdir = NULL; 3301722Sjkh p2->links = p2->objs = NULL; 3311722Sjkh p2->goterror = 0; 3326696Sphk if (list_mode) 3336696Sphk printf("%s\n",progname); 3341722Sjkh} 3351722Sjkh 3361722Sjkh 3371722Sjkhvoid add_link(int argc, char **argv) 3381722Sjkh{ 3391722Sjkh int i; 3401722Sjkh prog_t *p = find_prog(argv[1]); 3411722Sjkh 3421722Sjkh if(p == NULL) { 3438857Srgrimes fprintf(stderr, 3441722Sjkh "%s:%d: no prog %s previously declared, skipping link.\n", 3451722Sjkh curfilename, linenum, argv[1]); 3461722Sjkh goterror = 1; 3471722Sjkh return; 3481722Sjkh } 3496696Sphk for(i=2;i<argc;i++) { 3506696Sphk if (list_mode) 3516696Sphk printf("%s\n",argv[i]); 3521722Sjkh add_string(&p->links, argv[i]); 3536696Sphk } 3541722Sjkh} 3551722Sjkh 3561722Sjkh 3571722Sjkhvoid add_libs(int argc, char **argv) 3581722Sjkh{ 3591722Sjkh int i; 3601722Sjkh 3611722Sjkh for(i=1;i<argc;i++) 3621722Sjkh add_string(&libs, argv[i]); 3631722Sjkh} 3641722Sjkh 3651722Sjkh 3661722Sjkhvoid add_special(int argc, char **argv) 3671722Sjkh{ 3681722Sjkh int i; 3691722Sjkh prog_t *p = find_prog(argv[1]); 3701722Sjkh 3711722Sjkh if(p == NULL) { 3721722Sjkh if(reading_cache) return; 3738857Srgrimes fprintf(stderr, 3741722Sjkh "%s:%d: no prog %s previously declared, skipping special.\n", 3751722Sjkh curfilename, linenum, argv[1]); 3761722Sjkh goterror = 1; 3771722Sjkh return; 3781722Sjkh } 3791722Sjkh 3801722Sjkh if(!strcmp(argv[2], "ident")) { 3811722Sjkh if(argc != 4) goto argcount; 3821722Sjkh if((p->ident = strdup(argv[3])) == NULL) 3831722Sjkh out_of_memory(); 3841722Sjkh } 3851722Sjkh else if(!strcmp(argv[2], "srcdir")) { 3861722Sjkh if(argc != 4) goto argcount; 3871722Sjkh if((p->srcdir = strdup(argv[3])) == NULL) 3881722Sjkh out_of_memory(); 3891722Sjkh } 3901722Sjkh else if(!strcmp(argv[2], "objdir")) { 3911722Sjkh if(argc != 4) goto argcount; 3921722Sjkh if((p->objdir = strdup(argv[3])) == NULL) 3931722Sjkh out_of_memory(); 3941722Sjkh } 3951722Sjkh else if(!strcmp(argv[2], "objs")) { 3961722Sjkh p->objs = NULL; 3971722Sjkh for(i=3;i<argc;i++) 3981722Sjkh add_string(&p->objs, argv[i]); 3991722Sjkh } 4001722Sjkh else if(!strcmp(argv[2], "objpaths")) { 4011722Sjkh p->objpaths = NULL; 4021722Sjkh for(i=3;i<argc;i++) 4031722Sjkh add_string(&p->objpaths, argv[i]); 4041722Sjkh } 4051722Sjkh else { 4061722Sjkh fprintf(stderr, "%s:%d: bad parameter name `%s', skipping line.\n", 4071722Sjkh curfilename, linenum, argv[2]); 4081722Sjkh goterror = 1; 4091722Sjkh } 4101722Sjkh return; 4111722Sjkh 4121722Sjkh 4131722Sjkh argcount: 4148857Srgrimes fprintf(stderr, 4151722Sjkh "%s:%d: too %s arguments, expected \"special %s %s <string>\".\n", 4161722Sjkh curfilename, linenum, argc < 4? "few" : "many", argv[1], argv[2]); 4171722Sjkh goterror = 1; 4181722Sjkh} 4191722Sjkh 4201722Sjkh 4211722Sjkhprog_t *find_prog(char *str) 4221722Sjkh{ 4231722Sjkh prog_t *p; 4241722Sjkh 4251722Sjkh for(p = progs; p != NULL; p = p->next) 4261722Sjkh if(!strcmp(p->name, str)) return p; 4271722Sjkh 4281722Sjkh return NULL; 4291722Sjkh} 4301722Sjkh 4311722Sjkh 4321722Sjkh/* 4331722Sjkh * ======================================================================== 4341722Sjkh * gen_outputs subsystem 4351722Sjkh * 4361722Sjkh */ 4371722Sjkh 4381722Sjkh/* helper subroutines */ 4391722Sjkh 4401722Sjkhvoid remove_error_progs(void); 4411722Sjkhvoid fillin_program(prog_t *p); 4421722Sjkhvoid gen_specials_cache(void); 4431722Sjkhvoid gen_output_makefile(void); 4441722Sjkhvoid gen_output_cfile(void); 4451722Sjkh 4461722Sjkhvoid fillin_program_objs(prog_t *p, char *path); 4471722Sjkhvoid top_makefile_rules(FILE *outmk); 4481722Sjkhvoid prog_makefile_rules(FILE *outmk, prog_t *p); 4491722Sjkhvoid output_strlst(FILE *outf, strlst_t *lst); 4501722Sjkhchar *genident(char *str); 4511722Sjkhchar *dir_search(char *progname); 4521722Sjkh 4531722Sjkh 4541722Sjkhvoid gen_outputs(void) 4551722Sjkh{ 4561722Sjkh prog_t *p; 4571722Sjkh 4581722Sjkh for(p = progs; p != NULL; p = p->next) 4591722Sjkh fillin_program(p); 4601722Sjkh 4611722Sjkh remove_error_progs(); 4621722Sjkh gen_specials_cache(); 4631722Sjkh gen_output_cfile(); 4641722Sjkh gen_output_makefile(); 4651722Sjkh status(""); 4668857Srgrimes fprintf(stderr, 4671722Sjkh "Run \"make -f %s objs exe\" to build crunched binary.\n", 4681722Sjkh outmkname); 4691722Sjkh} 4701722Sjkh 4711722Sjkh 4721722Sjkhvoid fillin_program(prog_t *p) 4731722Sjkh{ 4741722Sjkh char path[MAXPATHLEN]; 4751722Sjkh char *srcparent; 4761722Sjkh strlst_t *s; 4771722Sjkh 4781722Sjkh sprintf(line, "filling in parms for %s", p->name); 4791722Sjkh status(line); 4801722Sjkh 4818857Srgrimes if(!p->ident) 4821722Sjkh p->ident = genident(p->name); 4831722Sjkh if(!p->srcdir) { 4841722Sjkh srcparent = dir_search(p->name); 4851722Sjkh if(srcparent) 4861722Sjkh sprintf(path, "%s/%s", srcparent, p->name); 4871722Sjkh if(is_dir(path)) 4881722Sjkh p->srcdir = strdup(path); 4891722Sjkh } 4901722Sjkh if(!p->objdir && p->srcdir) { 49117430Sphk FILE *f; 49217430Sphk 49317430Sphk sprintf(path, "cd %s && echo -n /usr/obj/`pwd`", p->srcdir); 49417430Sphk p->objdir = p->srcdir; 49517430Sphk f = popen(path,"r"); 49617430Sphk if (f) { 49717430Sphk fgets(path,sizeof path, f); 49817430Sphk if (!pclose(f)) { 49917430Sphk if(is_dir(path)) 50017430Sphk p->objdir = strdup(path); 50117430Sphk } 50217430Sphk } 50317430Sphk 50417430Sphk 5051722Sjkh } 5061722Sjkh 5071722Sjkh if(p->srcdir) sprintf(path, "%s/Makefile", p->srcdir); 5081722Sjkh if(!p->objs && p->srcdir && is_nonempty_file(path)) 5091722Sjkh fillin_program_objs(p, path); 5101722Sjkh 5111722Sjkh if(!p->objpaths && p->objdir && p->objs) 5121722Sjkh for(s = p->objs; s != NULL; s = s->next) { 5131722Sjkh sprintf(line, "%s/%s", p->objdir, s->str); 5141722Sjkh add_string(&p->objpaths, line); 5151722Sjkh } 5161722Sjkh 5171722Sjkh if(!p->srcdir && verbose) 5181722Sjkh fprintf(stderr, "%s: %s: warning: could not find source directory.\n", 5191722Sjkh infilename, p->name); 5201722Sjkh if(!p->objs && verbose) 5218857Srgrimes fprintf(stderr, "%s: %s: warning: could not find any .o files.\n", 5221722Sjkh infilename, p->name); 5231722Sjkh 5241722Sjkh if(!p->objpaths) { 5258857Srgrimes fprintf(stderr, 5261722Sjkh "%s: %s: error: no objpaths specified or calculated.\n", 5271722Sjkh infilename, p->name); 5281722Sjkh p->goterror = goterror = 1; 5291722Sjkh } 5301722Sjkh} 5311722Sjkh 5321722Sjkhvoid fillin_program_objs(prog_t *p, char *path) 5331722Sjkh{ 5341722Sjkh char *obj, *cp; 5351722Sjkh int rc; 5361722Sjkh FILE *f; 5371722Sjkh 5381722Sjkh /* discover the objs from the srcdir Makefile */ 5391722Sjkh 5401722Sjkh if((f = fopen(tempfname, "w")) == NULL) { 5411722Sjkh perror(tempfname); 5421722Sjkh goterror = 1; 5431722Sjkh return; 5441722Sjkh } 5458857Srgrimes 5461722Sjkh fprintf(f, ".include \"%s\"\n", path); 5471722Sjkh fprintf(f, ".if defined(PROG) && !defined(OBJS)\n"); 5481722Sjkh fprintf(f, "OBJS=${PROG}.o\n"); 5491722Sjkh fprintf(f, ".endif\n"); 5501722Sjkh fprintf(f, "crunchgen_objs:\n\t@echo 'OBJS= '${OBJS}\n"); 5511722Sjkh fclose(f); 5521722Sjkh 5531722Sjkh sprintf(line, "make -f %s crunchgen_objs 2>&1", tempfname); 5541722Sjkh if((f = popen(line, "r")) == NULL) { 5551722Sjkh perror("submake pipe"); 5561722Sjkh goterror = 1; 5571722Sjkh return; 5581722Sjkh } 5591722Sjkh 5601722Sjkh while(fgets(line, MAXLINELEN, f)) { 5611722Sjkh if(strncmp(line, "OBJS= ", 6)) { 5621722Sjkh fprintf(stderr, "make error: %s", line); 5638857Srgrimes goterror = 1; 5641722Sjkh continue; 5651722Sjkh } 5661722Sjkh cp = line + 6; 5671722Sjkh while(isspace(*cp)) cp++; 5681722Sjkh while(*cp) { 5691722Sjkh obj = cp; 5701722Sjkh while(*cp && !isspace(*cp)) cp++; 5711722Sjkh if(*cp) *cp++ = '\0'; 5721722Sjkh add_string(&p->objs, obj); 5731722Sjkh while(isspace(*cp)) cp++; 5741722Sjkh } 5751722Sjkh } 5761722Sjkh if((rc=pclose(f)) != 0) { 5771722Sjkh fprintf(stderr, "make error: make returned %d\n", rc); 5781722Sjkh goterror = 1; 5791722Sjkh } 5801722Sjkh unlink(tempfname); 5811722Sjkh} 5821722Sjkh 5831722Sjkhvoid remove_error_progs(void) 5841722Sjkh{ 5851722Sjkh prog_t *p1, *p2; 5861722Sjkh 5878857Srgrimes p1 = NULL; p2 = progs; 5888857Srgrimes while(p2 != NULL) { 5891722Sjkh if(!p2->goterror) 5901722Sjkh p1 = p2, p2 = p2->next; 5911722Sjkh else { 5921722Sjkh /* delete it from linked list */ 5931722Sjkh fprintf(stderr, "%s: %s: ignoring program because of errors.\n", 5941722Sjkh infilename, p2->name); 5951722Sjkh if(p1) p1->next = p2->next; 5961722Sjkh else progs = p2->next; 5971722Sjkh p2 = p2->next; 5981722Sjkh } 5991722Sjkh } 6001722Sjkh} 6011722Sjkh 6021722Sjkhvoid gen_specials_cache(void) 6031722Sjkh{ 6041722Sjkh FILE *cachef; 6051722Sjkh prog_t *p; 6061722Sjkh 6071722Sjkh sprintf(line, "generating %s", cachename); 6081722Sjkh status(line); 6091722Sjkh 6101722Sjkh if((cachef = fopen(cachename, "w")) == NULL) { 6111722Sjkh perror(cachename); 6121722Sjkh goterror = 1; 6131722Sjkh return; 6141722Sjkh } 6151722Sjkh 6161722Sjkh fprintf(cachef, "# %s - parm cache generated from %s by crunchgen %s\n\n", 6171722Sjkh cachename, infilename, CRUNCH_VERSION); 6181722Sjkh 6191722Sjkh for(p = progs; p != NULL; p = p->next) { 6201722Sjkh fprintf(cachef, "\n"); 6211722Sjkh if(p->srcdir) 6221722Sjkh fprintf(cachef, "special %s srcdir %s\n", p->name, p->srcdir); 6231722Sjkh if(p->objdir) 6241722Sjkh fprintf(cachef, "special %s objdir %s\n", p->name, p->objdir); 6251722Sjkh if(p->objs) { 6261722Sjkh fprintf(cachef, "special %s objs", p->name); 6271722Sjkh output_strlst(cachef, p->objs); 6281722Sjkh } 6291722Sjkh fprintf(cachef, "special %s objpaths", p->name); 6301722Sjkh output_strlst(cachef, p->objpaths); 6311722Sjkh } 6321722Sjkh fclose(cachef); 6331722Sjkh} 6341722Sjkh 6351722Sjkh 6361722Sjkhvoid gen_output_makefile(void) 6371722Sjkh{ 6381722Sjkh prog_t *p; 6391722Sjkh FILE *outmk; 6401722Sjkh 6411722Sjkh sprintf(line, "generating %s", outmkname); 6421722Sjkh status(line); 6431722Sjkh 6441722Sjkh if((outmk = fopen(outmkname, "w")) == NULL) { 6451722Sjkh perror(outmkname); 6461722Sjkh goterror = 1; 6471722Sjkh return; 6481722Sjkh } 6491722Sjkh 6501722Sjkh fprintf(outmk, "# %s - generated from %s by crunchgen %s\n\n", 6511722Sjkh outmkname, infilename, CRUNCH_VERSION); 6521722Sjkh 6531722Sjkh top_makefile_rules(outmk); 6541722Sjkh 6551722Sjkh for(p = progs; p != NULL; p = p->next) 6568857Srgrimes prog_makefile_rules(outmk, p); 6571722Sjkh 6581722Sjkh fprintf(outmk, "\n# ========\n"); 6591722Sjkh fclose(outmk); 6601722Sjkh} 6611722Sjkh 6621722Sjkh 6631722Sjkhvoid gen_output_cfile(void) 6641722Sjkh{ 6651722Sjkh extern char *crunched_skel[]; 6661722Sjkh char **cp; 6671722Sjkh FILE *outcf; 6681722Sjkh prog_t *p; 6691722Sjkh strlst_t *s; 6701722Sjkh 6711722Sjkh sprintf(line, "generating %s", outcfname); 6721722Sjkh status(line); 6731722Sjkh 6741722Sjkh if((outcf = fopen(outcfname, "w")) == NULL) { 6751722Sjkh perror(outcfname); 6761722Sjkh goterror = 1; 6771722Sjkh return; 6781722Sjkh } 6791722Sjkh 6808857Srgrimes fprintf(outcf, 6811722Sjkh "/* %s - generated from %s by crunchgen %s */\n", 6821722Sjkh outcfname, infilename, CRUNCH_VERSION); 6831722Sjkh 6841722Sjkh fprintf(outcf, "#define EXECNAME \"%s\"\n", execfname); 6851722Sjkh for(cp = crunched_skel; *cp != NULL; cp++) 6861722Sjkh fprintf(outcf, "%s\n", *cp); 6871722Sjkh 6881722Sjkh for(p = progs; p != NULL; p = p->next) 6891722Sjkh fprintf(outcf, "extern int _crunched_%s_stub();\n", p->ident); 6901722Sjkh 6911722Sjkh fprintf(outcf, "\nstruct stub entry_points[] = {\n"); 6921722Sjkh for(p = progs; p != NULL; p = p->next) { 6931722Sjkh fprintf(outcf, "\t{ \"%s\", _crunched_%s_stub },\n", 6941722Sjkh p->name, p->ident); 6951722Sjkh for(s = p->links; s != NULL; s = s->next) 6961722Sjkh fprintf(outcf, "\t{ \"%s\", _crunched_%s_stub },\n", 6971722Sjkh s->str, p->ident); 6981722Sjkh } 6998857Srgrimes 7001722Sjkh fprintf(outcf, "\t{ EXECNAME, crunched_main },\n"); 7011722Sjkh fprintf(outcf, "\t{ NULL, NULL }\n};\n"); 7021722Sjkh fclose(outcf); 7031722Sjkh} 7041722Sjkh 7051722Sjkh 7061722Sjkhchar *genident(char *str) 7071722Sjkh{ 7081722Sjkh char *n,*s,*d; 7091722Sjkh 7101722Sjkh /* 7111722Sjkh * generates a Makefile/C identifier from a program name, mapping '-' to 7121722Sjkh * '_' and ignoring all other non-identifier characters. This leads to 7131722Sjkh * programs named "foo.bar" and "foobar" to map to the same identifier. 7141722Sjkh */ 7151722Sjkh 7161722Sjkh if((n = strdup(str)) == NULL) 7171722Sjkh return NULL; 7181722Sjkh for(d = s = n; *s != '\0'; s++) { 7191722Sjkh if(*s == '-') *d++ = '_'; 7201722Sjkh else if(*s == '_' || isalnum(*s)) *d++ = *s; 7211722Sjkh } 7221722Sjkh *d = '\0'; 7231722Sjkh return n; 7241722Sjkh} 7251722Sjkh 7261722Sjkh 7271722Sjkhchar *dir_search(char *progname) 7281722Sjkh{ 7291722Sjkh char path[MAXPATHLEN]; 7301722Sjkh strlst_t *dir; 7311722Sjkh 7321722Sjkh for(dir=srcdirs; dir != NULL; dir=dir->next) { 7331722Sjkh sprintf(path, "%s/%s", dir->str, progname); 7341722Sjkh if(is_dir(path)) return dir->str; 7351722Sjkh } 7361722Sjkh return NULL; 7371722Sjkh} 7381722Sjkh 7391722Sjkh 7401722Sjkhvoid top_makefile_rules(FILE *outmk) 7411722Sjkh{ 7421722Sjkh prog_t *p; 7431722Sjkh 7441722Sjkh fprintf(outmk, "LIBS="); 7451722Sjkh output_strlst(outmk, libs); 7461722Sjkh 7471722Sjkh fprintf(outmk, "CRUNCHED_OBJS="); 7481722Sjkh for(p = progs; p != NULL; p = p->next) 7491722Sjkh fprintf(outmk, " %s.lo", p->name); 7501722Sjkh fprintf(outmk, "\n"); 7511722Sjkh 7521722Sjkh fprintf(outmk, "SUBMAKE_TARGETS="); 7531722Sjkh for(p = progs; p != NULL; p = p->next) 7541722Sjkh fprintf(outmk, " %s_make", p->ident); 7551722Sjkh fprintf(outmk, "\n\n"); 7561722Sjkh 7578857Srgrimes fprintf(outmk, "%s: %s.o $(CRUNCHED_OBJS)\n", 7581722Sjkh execfname, execfname); 7591722Sjkh fprintf(outmk, "\t$(CC) -static -o %s %s.o $(CRUNCHED_OBJS) $(LIBS)\n", 7601722Sjkh execfname, execfname); 7611722Sjkh fprintf(outmk, "\tstrip %s\n", execfname); 7621722Sjkh fprintf(outmk, "all: objs exe\nobjs: $(SUBMAKE_TARGETS)\n"); 7631722Sjkh fprintf(outmk, "exe: %s\n", execfname); 7641722Sjkh fprintf(outmk, "clean:\n\trm -f %s *.lo *.o *_stub.c\n", 7651722Sjkh execfname); 7661722Sjkh} 7671722Sjkh 7681722Sjkh 7691722Sjkhvoid prog_makefile_rules(FILE *outmk, prog_t *p) 7701722Sjkh{ 7711722Sjkh fprintf(outmk, "\n# -------- %s\n\n", p->name); 7721722Sjkh 7731722Sjkh if(p->srcdir && p->objs) { 7741722Sjkh fprintf(outmk, "%s_SRCDIR=%s\n", p->ident, p->srcdir); 7751722Sjkh fprintf(outmk, "%s_OBJS=", p->ident); 7761722Sjkh output_strlst(outmk, p->objs); 7771722Sjkh fprintf(outmk, "%s_make:\n", p->ident); 77817430Sphk fprintf(outmk, "\t(cd $(%s_SRCDIR) && make depend && make $(%s_OBJS))\n\n", 7791722Sjkh p->ident, p->ident); 7801722Sjkh } 7811722Sjkh else 7828857Srgrimes fprintf(outmk, "%s_make:\n\t@echo \"** cannot make objs for %s\"\n\n", 7831722Sjkh p->ident, p->name); 7841722Sjkh 7851722Sjkh fprintf(outmk, "%s_OBJPATHS=", p->ident); 7861722Sjkh output_strlst(outmk, p->objpaths); 7871722Sjkh 7881722Sjkh fprintf(outmk, "%s_stub.c:\n", p->name); 7891722Sjkh fprintf(outmk, "\techo \"" 7901722Sjkh "int _crunched_%s_stub(int argc, char **argv, char **envp)" 7911722Sjkh "{return main(argc,argv,envp);}\" >%s_stub.c\n", 7921722Sjkh p->ident, p->name); 7931722Sjkh fprintf(outmk, "%s.lo: %s_stub.o $(%s_OBJPATHS)\n", 7941722Sjkh p->name, p->name, p->ident); 7958857Srgrimes fprintf(outmk, "\tld -dc -r -o %s.lo %s_stub.o $(%s_OBJPATHS)\n", 7961722Sjkh p->name, p->name, p->ident); 7978857Srgrimes fprintf(outmk, "\tcrunchide -k __crunched_%s_stub %s.lo\n", 7981722Sjkh p->ident, p->name); 7991722Sjkh} 8001722Sjkh 8011722Sjkhvoid output_strlst(FILE *outf, strlst_t *lst) 8021722Sjkh{ 8031722Sjkh for(; lst != NULL; lst = lst->next) 8041722Sjkh fprintf(outf, " %s", lst->str); 8051722Sjkh fprintf(outf, "\n"); 8061722Sjkh} 8071722Sjkh 8081722Sjkh 8091722Sjkh/* 8101722Sjkh * ======================================================================== 8111722Sjkh * general library routines 8121722Sjkh * 8131722Sjkh */ 8141722Sjkh 8151722Sjkhvoid status(char *str) 8161722Sjkh{ 8171722Sjkh static int lastlen = 0; 8181722Sjkh int len, spaces; 8191722Sjkh 8201722Sjkh if(!verbose) return; 8211722Sjkh 8221722Sjkh len = strlen(str); 8231722Sjkh spaces = lastlen - len; 8241722Sjkh if(spaces < 1) spaces = 1; 8251722Sjkh 8261722Sjkh fprintf(stderr, " [%s]%*.*s\r", str, spaces, spaces, " "); 8271722Sjkh fflush(stderr); 8281722Sjkh lastlen = len; 8291722Sjkh} 8301722Sjkh 8311722Sjkh 8321722Sjkhvoid out_of_memory(void) 8331722Sjkh{ 8341722Sjkh fprintf(stderr, "%s: %d: out of memory, stopping.\n", infilename, linenum); 8351722Sjkh exit(1); 8361722Sjkh} 8371722Sjkh 8381722Sjkh 8391722Sjkhvoid add_string(strlst_t **listp, char *str) 8401722Sjkh{ 8411722Sjkh strlst_t *p1, *p2; 8421722Sjkh 8431722Sjkh /* add to end, but be smart about dups */ 8441722Sjkh 8451722Sjkh for(p1 = NULL, p2 = *listp; p2 != NULL; p1 = p2, p2 = p2->next) 8461722Sjkh if(!strcmp(p2->str, str)) return; 8471722Sjkh 8481722Sjkh p2 = malloc(sizeof(strlst_t)); 8491722Sjkh if(p2) p2->str = strdup(str); 8501722Sjkh if(!p2 || !p2->str) 8511722Sjkh out_of_memory(); 8521722Sjkh 8531722Sjkh p2->next = NULL; 8541722Sjkh if(p1 == NULL) *listp = p2; 8551722Sjkh else p1->next = p2; 8561722Sjkh} 8571722Sjkh 8581722Sjkh 8591722Sjkhint is_dir(char *pathname) 8601722Sjkh{ 8611722Sjkh struct stat buf; 8621722Sjkh 8631722Sjkh if(stat(pathname, &buf) == -1) 8641722Sjkh return 0; 8651722Sjkh return S_ISDIR(buf.st_mode); 8661722Sjkh} 8671722Sjkh 8681722Sjkhint is_nonempty_file(char *pathname) 8691722Sjkh{ 8701722Sjkh struct stat buf; 8711722Sjkh 8721722Sjkh if(stat(pathname, &buf) == -1) 8731722Sjkh return 0; 8741722Sjkh 8751722Sjkh return S_ISREG(buf.st_mode) && buf.st_size > 0; 8761722Sjkh} 877