1: /* 2: * Copyright (c) 1980 Regents of the University of California. 3: * All rights reserved. The Berkeley software License Agreement 4: * specifies the terms and conditions for redistribution. 5: */ 6: 7: #ifndef lint 8: static char sccsid[] = "@(#)mkmakefile.c 5.9 (Berkeley) 5/6/86"; 9: #endif not lint 10: 11: /* 12: * Build the makefile for the system, from 13: * the information in the files files and the 14: * additional files for the machine being compiled to. 15: */ 16: 17: #include <stdio.h> 18: #include <ctype.h> 19: #include "y.tab.h" 20: #include "config.h" 21: 22: #define next_word(fp, wd) \ 23: { register char *word = get_word(fp); \ 24: if (word == (char *)EOF) \ 25: return; \ 26: else \ 27: wd = word; \ 28: } 29: 30: static struct file_list *fcur; 31: char *tail(); 32: 33: /* 34: * Lookup a file, by name. 35: */ 36: struct file_list * 37: fl_lookup(file) 38: register char *file; 39: { 40: register struct file_list *fp; 41: 42: for (fp = ftab ; fp != 0; fp = fp->f_next) { 43: if (eq(fp->f_fn, file)) 44: return (fp); 45: } 46: return (0); 47: } 48: 49: /* 50: * Lookup a file, by final component name. 51: */ 52: struct file_list * 53: fltail_lookup(file) 54: register char *file; 55: { 56: register struct file_list *fp; 57: 58: for (fp = ftab ; fp != 0; fp = fp->f_next) { 59: if (eq(tail(fp->f_fn), tail(file))) 60: return (fp); 61: } 62: return (0); 63: } 64: 65: /* 66: * Make a new file list entry 67: */ 68: struct file_list * 69: new_fent() 70: { 71: register struct file_list *fp; 72: 73: fp = (struct file_list *) malloc(sizeof *fp); 74: fp->f_needs = 0; 75: fp->f_next = 0; 76: fp->f_flags = 0; 77: fp->f_type = 0; 78: if (fcur == 0) 79: fcur = ftab = fp; 80: else 81: fcur->f_next = fp; 82: fcur = fp; 83: return (fp); 84: } 85: 86: char *COPTS; 87: static struct users { 88: int u_default; 89: int u_min; 90: int u_max; 91: } users[] = { 92: { 24, 8, 1024 }, /* MACHINE_VAX */ 93: }; 94: #define NUSERS (sizeof (users) / sizeof (users[0])) 95: 96: /* 97: * Build the makefile from the skeleton 98: */ 99: makefile() 100: { 101: FILE *ifp, *ofp; 102: char line[BUFSIZ]; 103: struct opt *op; 104: struct users *up; 105: 106: read_files(); 107: strcpy(line, "../conf/Makefile."); 108: (void) strcat(line, machinename); 109: ifp = fopen(line, "r"); 110: if (ifp == 0) { 111: perror(line); 112: exit(1); 113: } 114: ofp = fopen(path("Makefile"), "w"); 115: if (ofp == 0) { 116: perror(path("Makefile")); 117: exit(1); 118: } 119: fprintf(ofp, "IDENT=-D%s", raise(ident)); 120: if (profiling) 121: fprintf(ofp, " -DGPROF"); 122: if (cputype == 0) { 123: printf("cpu type must be specified\n"); 124: exit(1); 125: } 126: { struct cputype *cp; 127: for (cp = cputype; cp; cp = cp->cpu_next) 128: fprintf(ofp, " -D%s", cp->cpu_name); 129: } 130: for (op = opt; op; op = op->op_next) 131: if (op->op_value) 132: fprintf(ofp, " -D%s=\"%s\"", op->op_name, op->op_value); 133: else 134: fprintf(ofp, " -D%s", op->op_name); 135: fprintf(ofp, "\n"); 136: if (hadtz == 0) 137: printf("timezone not specified; gmt assumed\n"); 138: if ((unsigned)machine > NUSERS) { 139: printf("maxusers config info isn't present, using vax\n"); 140: up = &users[MACHINE_VAX-1]; 141: } else 142: up = &users[machine-1]; 143: if (maxusers == 0) { 144: printf("maxusers not specified; %d assumed\n", up->u_default); 145: maxusers = up->u_default; 146: } else if (maxusers < up->u_min) { 147: printf("minimum of %d maxusers assumed\n", up->u_min); 148: maxusers = up->u_min; 149: } else if (maxusers > up->u_max) 150: printf("warning: maxusers > %d (%d)\n", up->u_max, maxusers); 151: fprintf(ofp, "PARAM=-DTIMEZONE=%d -DDST=%d -DMAXUSERS=%d\n", 152: timezone, dst, maxusers); 153: for (op = mkopt; op; op = op->op_next) 154: fprintf(ofp, "%s=%s\n", op->op_name, op->op_value); 155: while (fgets(line, BUFSIZ, ifp) != 0) { 156: if (*line == '%') 157: goto percent; 158: if (profiling && strncmp(line, "COPTS=", 6) == 0) { 159: register char *cp; 160: 161: fprintf(ofp, 162: "GPROF.EX=/usr/src/lib/libc/%s/csu/gmon.ex\n", 163: machinename); 164: cp = index(line, '\n'); 165: if (cp) 166: *cp = 0; 167: cp = line + 6; 168: while (*cp && (*cp == ' ' || *cp == '\t')) 169: cp++; 170: COPTS = malloc((unsigned)(strlen(cp) + 1)); 171: if (COPTS == 0) { 172: printf("config: out of memory\n"); 173: exit(1); 174: } 175: strcpy(COPTS, cp); 176: fprintf(ofp, "%s -pg\n", line); 177: continue; 178: } 179: fprintf(ofp, "%s", line); 180: continue; 181: percent: 182: if (eq(line, "%OBJS\n")) 183: do_objs(ofp); 184: else if (eq(line, "%CFILES\n")) 185: do_cfiles(ofp); 186: else if (eq(line, "%RULES\n")) 187: do_rules(ofp); 188: else if (eq(line, "%LOAD\n")) 189: do_load(ofp); 190: else 191: fprintf(stderr, 192: "Unknown %% construct in generic makefile: %s", 193: line); 194: } 195: (void) fclose(ifp); 196: (void) fclose(ofp); 197: } 198: 199: /* 200: * Read in the information about files used in making the system. 201: * Store it in the ftab linked list. 202: */ 203: read_files() 204: { 205: FILE *fp; 206: register struct file_list *tp, *pf; 207: register struct device *dp; 208: register struct opt *op; 209: char *wd, *this, *needs, *devorprof; 210: char fname[32]; 211: int nreqs, first = 1, configdep, isdup; 212: 213: ftab = 0; 214: (void) strcpy(fname, "files"); 215: openit: 216: fp = fopen(fname, "r"); 217: if (fp == 0) { 218: perror(fname); 219: exit(1); 220: } 221: next: 222: /* 223: * filename [ standard | optional ] [ config-dependent ] 224: * [ dev* | profiling-routine ] [ device-driver] 225: */ 226: wd = get_word(fp); 227: if (wd == (char *)EOF) { 228: (void) fclose(fp); 229: if (first == 1) { 230: (void) sprintf(fname, "files.%s", machinename); 231: first++; 232: goto openit; 233: } 234: if (first == 2) { 235: (void) sprintf(fname, "files.%s", raise(ident)); 236: first++; 237: fp = fopen(fname, "r"); 238: if (fp != 0) 239: goto next; 240: } 241: return; 242: } 243: if (wd == 0) 244: goto next; 245: this = ns(wd); 246: next_word(fp, wd); 247: if (wd == 0) { 248: printf("%s: No type for %s.\n", 249: fname, this); 250: exit(1); 251: } 252: if ((pf = fl_lookup(this)) && (pf->f_type != INVISIBLE || pf->f_flags)) 253: isdup = 1; 254: else 255: isdup = 0; 256: tp = 0; 257: if (first == 3 && (tp = fltail_lookup(this)) != 0) 258: printf("%s: Local file %s overrides %s.\n", 259: fname, this, tp->f_fn); 260: nreqs = 0; 261: devorprof = ""; 262: configdep = 0; 263: needs = 0; 264: if (eq(wd, "standard")) 265: goto checkdev; 266: if (!eq(wd, "optional")) { 267: printf("%s: %s must be optional or standard\n", fname, this); 268: exit(1); 269: } 270: nextopt: 271: next_word(fp, wd); 272: if (wd == 0) 273: goto doneopt; 274: if (eq(wd, "config-dependent")) { 275: configdep++; 276: goto nextopt; 277: } 278: devorprof = wd; 279: if (eq(wd, "device-driver") || eq(wd, "profiling-routine")) { 280: next_word(fp, wd); 281: goto save; 282: } 283: nreqs++; 284: if (needs == 0 && nreqs == 1) 285: needs = ns(wd); 286: if (isdup) 287: goto invis; 288: for (dp = dtab; dp != 0; dp = dp->d_next) 289: if (eq(dp->d_name, wd)) 290: goto nextopt; 291: for (op = opt; op != 0; op = op->op_next) 292: if (op->op_value == 0 && opteq(op->op_name, wd)) { 293: if (nreqs == 1) { 294: free(needs); 295: needs = 0; 296: } 297: goto nextopt; 298: } 299: invis: 300: while ((wd = get_word(fp)) != 0) 301: ; 302: if (tp == 0) 303: tp = new_fent(); 304: tp->f_fn = this; 305: tp->f_type = INVISIBLE; 306: tp->f_needs = needs; 307: tp->f_flags = isdup; 308: goto next; 309: 310: doneopt: 311: if (nreqs == 0) { 312: printf("%s: what is %s optional on?\n", 313: fname, this); 314: exit(1); 315: } 316: 317: checkdev: 318: if (wd) { 319: next_word(fp, wd); 320: if (wd) { 321: if (eq(wd, "config-dependent")) { 322: configdep++; 323: goto checkdev; 324: } 325: devorprof = wd; 326: next_word(fp, wd); 327: } 328: } 329: 330: save: 331: if (wd) { 332: printf("%s: syntax error describing %s\n", 333: fname, this); 334: exit(1); 335: } 336: if (eq(devorprof, "profiling-routine") && profiling == 0) 337: goto next; 338: if (tp == 0) 339: tp = new_fent(); 340: tp->f_fn = this; 341: if (eq(devorprof, "device-driver")) 342: tp->f_type = DRIVER; 343: else if (eq(devorprof, "profiling-routine")) 344: tp->f_type = PROFILING; 345: else 346: tp->f_type = NORMAL; 347: tp->f_flags = 0; 348: if (configdep) 349: tp->f_flags |= CONFIGDEP; 350: tp->f_needs = needs; 351: if (pf && pf->f_type == INVISIBLE) 352: pf->f_flags = 1; /* mark as duplicate */ 353: goto next; 354: } 355: 356: opteq(cp, dp) 357: char *cp, *dp; 358: { 359: char c, d; 360: 361: for (; ; cp++, dp++) { 362: if (*cp != *dp) { 363: c = isupper(*cp) ? tolower(*cp) : *cp; 364: d = isupper(*dp) ? tolower(*dp) : *dp; 365: if (c != d) 366: return (0); 367: } 368: if (*cp == 0) 369: return (1); 370: } 371: } 372: 373: do_objs(fp) 374: FILE *fp; 375: { 376: register struct file_list *tp, *fl; 377: register int lpos, len; 378: register char *cp, och, *sp; 379: char swapname[32]; 380: 381: fprintf(fp, "OBJS="); 382: lpos = 6; 383: for (tp = ftab; tp != 0; tp = tp->f_next) { 384: if (tp->f_type == INVISIBLE) 385: continue; 386: sp = tail(tp->f_fn); 387: for (fl = conf_list; fl; fl = fl->f_next) { 388: if (fl->f_type != SWAPSPEC) 389: continue; 390: sprintf(swapname, "swap%s.c", fl->f_fn); 391: if (eq(sp, swapname)) 392: goto cont; 393: } 394: cp = sp + (len = strlen(sp)) - 1; 395: och = *cp; 396: *cp = 'o'; 397: if (len + lpos > 72) { 398: lpos = 8; 399: fprintf(fp, "\\\n\t"); 400: } 401: fprintf(fp, "%s ", sp); 402: lpos += len + 1; 403: *cp = och; 404: cont: 405: ; 406: } 407: if (lpos != 8) 408: putc('\n', fp); 409: } 410: 411: do_cfiles(fp) 412: FILE *fp; 413: { 414: register struct file_list *tp; 415: register int lpos, len; 416: 417: fprintf(fp, "CFILES="); 418: lpos = 8; 419: for (tp = ftab; tp != 0; tp = tp->f_next) { 420: if (tp->f_type == INVISIBLE) 421: continue; 422: if (tp->f_fn[strlen(tp->f_fn)-1] != 'c') 423: continue; 424: if ((len = 3 + strlen(tp->f_fn)) + lpos > 72) { 425: lpos = 8; 426: fprintf(fp, "\\\n\t"); 427: } 428: fprintf(fp, "../%s ", tp->f_fn); 429: lpos += len + 1; 430: } 431: if (lpos != 8) 432: putc('\n', fp); 433: } 434: 435: char * 436: tail(fn) 437: char *fn; 438: { 439: register char *cp; 440: 441: cp = rindex(fn, '/'); 442: if (cp == 0) 443: return (fn); 444: return (cp+1); 445: } 446: 447: /* 448: * Create the makerules for each file 449: * which is part of the system. 450: * Devices are processed with the special c2 option -i 451: * which avoids any problem areas with i/o addressing 452: * (e.g. for the VAX); assembler files are processed by as. 453: */ 454: do_rules(f) 455: FILE *f; 456: { 457: register char *cp, *np, och, *tp; 458: register struct file_list *ftp; 459: char *extras; 460: 461: for (ftp = ftab; ftp != 0; ftp = ftp->f_next) { 462: if (ftp->f_type == INVISIBLE) 463: continue; 464: cp = (np = ftp->f_fn) + strlen(ftp->f_fn) - 1; 465: och = *cp; 466: *cp = '\0'; 467: if (och == 'o') { 468: fprintf(f, "%so:\n\t-cp ../%so .\n", tail(np), np); 469: continue; 470: } 471: fprintf(f, "%so: ../%s%c\n", tail(np), np, och); 472: tp = tail(np); 473: if (och == 's') { 474: fprintf(f, "\t-ln -s ../%ss %sc\n", np, tp); 475: fprintf(f, "\t${CC} -E ${COPTS} %sc | ${AS} -o %so\n", 476: tp, tp); 477: fprintf(f, "\trm -f %sc\n\n", tp); 478: continue; 479: } 480: if (ftp->f_flags & CONFIGDEP) 481: extras = "${PARAM} "; 482: else 483: extras = ""; 484: switch (ftp->f_type) { 485: 486: case NORMAL: 487: switch (machine) { 488: 489: case MACHINE_VAX: 490: fprintf(f, "\t${CC} -c -S ${COPTS} %s../%sc\n", 491: extras, np); 492: fprintf(f, "\t${C2} %ss | ${INLINE} | ${AS} -o %so\n", 493: tp, tp); 494: fprintf(f, "\trm -f %ss\n\n", tp); 495: break; 496: } 497: break; 498: 499: case DRIVER: 500: switch (machine) { 501: 502: case MACHINE_VAX: 503: fprintf(f, "\t${CC} -c -S ${COPTS} %s../%sc\n", 504: extras, np); 505: fprintf(f,"\t${C2} -i %ss | ${INLINE} | ${AS} -o %so\n", 506: tp, tp); 507: fprintf(f, "\trm -f %ss\n\n", tp); 508: break; 509: } 510: break; 511: 512: case PROFILING: 513: if (!profiling) 514: continue; 515: if (COPTS == 0) { 516: fprintf(stderr, 517: "config: COPTS undefined in generic makefile"); 518: COPTS = ""; 519: } 520: switch (machine) { 521: 522: case MACHINE_VAX: 523: fprintf(f, "\t${CC} -c -S %s %s../%sc\n", 524: COPTS, extras, np); 525: fprintf(f, "\tex - %ss < ${GPROF.EX}\n", tp); 526: fprintf(f, "\t${INLINE} %ss | ${AS} -o %so\n", tp, tp); 527: fprintf(f, "\trm -f %ss\n\n", tp); 528: break; 529: } 530: break; 531: 532: default: 533: printf("Don't know rules for %s\n", np); 534: break; 535: } 536: *cp = och; 537: } 538: } 539: 540: /* 541: * Create the load strings 542: */ 543: do_load(f) 544: register FILE *f; 545: { 546: register struct file_list *fl; 547: int first = 1; 548: struct file_list *do_systemspec(); 549: 550: fl = conf_list; 551: while (fl) { 552: if (fl->f_type != SYSTEMSPEC) { 553: fl = fl->f_next; 554: continue; 555: } 556: fl = do_systemspec(f, fl, first); 557: if (first) 558: first = 0; 559: } 560: fprintf(f, "all:"); 561: for (fl = conf_list; fl != 0; fl = fl->f_next) 562: if (fl->f_type == SYSTEMSPEC) 563: fprintf(f, " %s", fl->f_needs); 564: fprintf(f, "\n"); 565: } 566: 567: struct file_list * 568: do_systemspec(f, fl, first) 569: FILE *f; 570: register struct file_list *fl; 571: int first; 572: { 573: 574: fprintf(f, "%s: Makefile", fl->f_needs); 575: if (machine == MACHINE_VAX) 576: fprintf(f, " ${INLINECMD}", machinename); 577: fprintf(f, " locore.o emulate.o ${OBJS} param.o ioconf.o swap%s.o\n", 578: fl->f_fn); 579: fprintf(f, "\t@echo loading %s\n\t@rm -f %s\n", 580: fl->f_needs, fl->f_needs); 581: if (first) { 582: fprintf(f, "\t@sh ../conf/newvers.sh\n"); 583: fprintf(f, "\t@${CC} $(CFLAGS) -c vers.c\n"); 584: } 585: switch (machine) { 586: 587: case MACHINE_VAX: 588: fprintf(f, "\t@${LD} -n -o %s -e start -x -T 80000000 ", 589: fl->f_needs); 590: break; 591: } 592: fprintf(f, "locore.o emulate.o ${OBJS} vers.o ioconf.o param.o "); 593: fprintf(f, "swap%s.o\n", fl->f_fn); 594: fprintf(f, "\t@echo rearranging symbols\n"); 595: fprintf(f, "\t@-symorder ../%s/symbols.sort %s\n", 596: machinename, fl->f_needs); 597: fprintf(f, "\t@size %s\n", fl->f_needs); 598: fprintf(f, "\t@chmod 755 %s\n\n", fl->f_needs); 599: do_swapspec(f, fl->f_fn); 600: for (fl = fl->f_next; fl->f_type == SWAPSPEC; fl = fl->f_next) 601: ; 602: return (fl); 603: } 604: 605: do_swapspec(f, name) 606: FILE *f; 607: register char *name; 608: { 609: 610: if (!eq(name, "generic")) { 611: fprintf(f, "swap%s.o: swap%s.c\n", name, name); 612: fprintf(f, "\t${CC} -c -O ${COPTS} swap%s.c\n\n", name); 613: return; 614: } 615: fprintf(f, "swapgeneric.o: ../%s/swapgeneric.c\n", machinename); 616: switch (machine) { 617: 618: case MACHINE_VAX: 619: fprintf(f, "\t${CC} -c -S ${COPTS} "); 620: fprintf(f, "../%s/swapgeneric.c\n", machinename); 621: fprintf(f, "\t${C2} swapgeneric.s | ${INLINE}"); 622: fprintf(f, " | ${AS} -o swapgeneric.o\n"); 623: fprintf(f, "\trm -f swapgeneric.s\n\n"); 624: break; 625: } 626: } 627: 628: char * 629: raise(str) 630: register char *str; 631: { 632: register char *cp = str; 633: 634: while (*str) { 635: if (islower(*str)) 636: *str = toupper(*str); 637: str++; 638: } 639: return (cp); 640: }
Defined functions
Defined variables
Defined struct's
Defined macros
|
Last modified: 1986-05-07
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 2657 |
|