SETUP/config/mkmakefile.c

   1 /*
   2  * Copyright (c) 1999-2016 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
   7  * Reserved.  This file contains Original Code and/or Modifications of
   8  * Original Code as defined in and that are subject to the Apple Public
   9  * Source License Version 1.0 (the 'License').  You may not use this file
  10  * except in compliance with the License.  Please obtain a copy of the
  11  * License at http://www.apple.com/publicsource and read it before using
  12  * this file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  19  * License for the specific language governing rights and limitations
  20  * under the License."
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24 /*
  25  * Mach Operating System
  26  * Copyright (c) 1990 Carnegie-Mellon University
  27  * Copyright (c) 1989 Carnegie-Mellon University
  28  * Copyright (c) 1988 Carnegie-Mellon University
  29  * Copyright (c) 1987 Carnegie-Mellon University
  30  * All rights reserved.  The CMU software License Agreement specifies
  31  * the terms and conditions for use and redistribution.
  32  */
  33
  34 /*
  35  * Copyright (c) 1980 Regents of the University of California.
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms are permitted
  39  * provided that the above copyright notice and this paragraph are
  40  * duplicated in all such forms and that any documentation,
  41  * advertising materials, and other materials related to such
  42  * distribution and use acknowledge that the software was developed
  43  * by the University of California, Berkeley.  The name of the
  44  * University may not be used to endorse or promote products derived
  45  * from this software without specific prior written permission.
  46  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  47  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  48  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  49  */
  50
  51 #ifndef lint
  52 static char sccsid[] __attribute__((used)) = "@(#)mkmakefile.c  5.21 (Berkeley) 6/18/88";
  53 #endif /* not lint */
  54
  55 /*
  56  * Build the makefile for the system, from
  57  * the information in the files files and the
  58  * additional files for the machine being compiled to.
  59  */
  60
  61 #include <stdio.h>
  62 #include <unistd.h>     /* for unlink */
  63 #include <ctype.h>
  64 #include "parser.h"
  65 #include "config.h"
  66
  67 void    read_files(void);
  68 void    do_objs(FILE *fp, const char *msg, int ext, int flags);
  69 void    do_files(FILE *fp, const char *msg, char ext);
  70 void    do_machdep(FILE *ofp);
  71 void    do_rules(FILE *f);
  72 void    copy_dependencies(FILE *makin, FILE *makout);
  73
  74 struct file_list *fl_lookup(char *file);
  75 struct file_list *fltail_lookup(char *file);
  76 struct file_list *new_fent(void);
  77
  78 void    put_source_file_name(FILE *fp, struct file_list *tp);
  79
  80
  81 #define next_word(fp, wd) \
  82         { const char *word = get_word(fp); \
  83           if (word == (char *)EOF) \
  84                 return; \
  85           else \
  86                 wd = word; \
  87         }
  88
  89 static  struct file_list *fcur;
  90 const char *tail(const char *fn);
  91 char *allCaps(char *str);
  92
  93 /*
  94  * Lookup a file, by name.
  95  */
  96 struct file_list *
  97 fl_lookup(char *file)
  98 {
  99         struct file_list *fp;
 100
 101         for (fp = ftab; fp != 0; fp = fp->f_next) {
 102                 if (eq(fp->f_fn, file)) {
 103                         return fp;
 104                 }
 105         }
 106         return 0;
 107 }
 108
 109 /*
 110  * Lookup a file, by final component name.
 111  */
 112 struct file_list *
 113 fltail_lookup(char *file)
 114 {
 115         struct file_list *fp;
 116
 117         for (fp = ftab; fp != 0; fp = fp->f_next) {
 118                 if (eq(tail(fp->f_fn), tail(file))) {
 119                         return fp;
 120                 }
 121         }
 122         return 0;
 123 }
 124
 125 /*
 126  * Make a new file list entry
 127  */
 128 struct file_list *
 129 new_fent(void)
 130 {
 131         struct file_list *fp;
 132
 133         fp = (struct file_list *) malloc(sizeof *fp);
 134         fp->f_needs = 0;
 135         fp->f_next = 0;
 136         fp->f_flags = 0;
 137         fp->f_type = 0;
 138         fp->f_extra = (char *) 0;
 139         if (fcur == 0) {
 140                 fcur = ftab = fp;
 141         } else {
 142                 fcur->f_next = fp;
 143         }
 144         fcur = fp;
 145         return fp;
 146 }
 147
 148 char    *COPTS;
 149
 150 const char *
 151 get_VPATH(void)
 152 {
 153         static char *vpath = NULL;
 154
 155         if ((vpath == NULL) &&
 156             ((vpath = getenv("VPATH")) != NULL) &&
 157             (*vpath != ':')) {
 158                 char *buf = malloc((unsigned)(strlen(vpath) + 2));
 159
 160                 vpath = strcat(strcpy(buf, ":"), vpath);
 161         }
 162
 163         return vpath ? vpath : "";
 164 }
 165
 166
 167 /*
 168  * Build the makefile from the skeleton
 169  */
 170 void
 171 makefile(void)
 172 {
 173         FILE *ifp, *ofp;
 174         FILE *dfp;
 175         char pname[BUFSIZ];
 176         char line[BUFSIZ];
 177         struct opt *op;
 178
 179         read_files();
 180         (void) sprintf(line, "%s/Makefile.template", config_directory);
 181         ifp = fopenp(VPATH, line, pname, "r");
 182         if (ifp == 0) {
 183                 perror(line);
 184                 exit(1);
 185         }
 186         dfp = fopen(path("Makefile"), "r");
 187         rename(path("Makefile"), path("Makefile.old"));
 188         unlink(path("Makefile.old"));
 189         ofp = fopen(path("Makefile"), "w");
 190         if (ofp == 0) {
 191                 perror(path("Makefile"));
 192                 exit(1);
 193         }
 194         fprintf(ofp, "SOURCE_DIR=%s\n", source_directory);
 195
 196         fprintf(ofp, "export CONFIG_DEFINES =");
 197         if (profiling) {
 198                 fprintf(ofp, " -DGPROF");
 199         }
 200
 201         for (op = opt; op; op = op->op_next) {
 202                 if (op->op_value) {
 203                         fprintf(ofp, " -D%s=\"%s\"", op->op_name, op->op_value);
 204                 } else {
 205                         fprintf(ofp, " -D%s", op->op_name);
 206                 }
 207         }
 208         fprintf(ofp, "\n");
 209         for (op = mkopt; op; op = op->op_next) {
 210                 if (op->op_value) {
 211                         fprintf(ofp, "%s=%s\n", op->op_name, op->op_value);
 212                 } else {
 213                         fprintf(ofp, "%s\n", op->op_name);
 214                 }
 215         }
 216
 217         while (fgets(line, BUFSIZ, ifp) != 0) {
 218                 if (*line == '%') {
 219                         goto percent;
 220                 }
 221                 if (profiling && strncmp(line, "COPTS=", 6) == 0) {
 222                         char *cp;
 223                         fprintf(ofp,
 224                             "GPROF.EX=$(SOURCE_DIR)/machdep/%s/gmon.ex\n", machinename);
 225                         cp = index(line, '\n');
 226                         if (cp) {
 227                                 *cp = 0;
 228                         }
 229                         cp = line + 6;
 230                         while (*cp && (*cp == ' ' || *cp == '\t')) {
 231                                 cp++;
 232                         }
 233                         COPTS = malloc((unsigned)(strlen(cp) + 1));
 234                         if (COPTS == 0) {
 235                                 printf("config: out of memory\n");
 236                                 exit(1);
 237                         }
 238                         strcpy(COPTS, cp);
 239                         fprintf(ofp, "%s -pg\n", line);
 240                         continue;
 241                 }
 242                 fprintf(ofp, "%s", line);
 243                 continue;
 244 percent:
 245                 if (eq(line, "%OBJS\n")) {
 246                         do_objs(ofp, "OBJS=", -1, 0);
 247                 } else if (eq(line, "%LIBOBJS\n")) {
 248                         do_objs(ofp, "LIBOBJS=", -1, LIBRARYDEP);
 249                 } else if (eq(line, "%CFILES\n")) {
 250                         do_files(ofp, "CFILES=", 'c');
 251                         do_objs(ofp, "COBJS=", 'c', 0);
 252                 } else if (eq(line, "%CXXFILES\n")) {
 253                         do_files(ofp, "CXXFILES=", 'p');
 254                         do_objs(ofp, "CXXOBJS=", 'p', 0);
 255                 } else if (eq(line, "%SFILES\n")) {
 256                         do_files(ofp, "SFILES=", 's');
 257                         do_objs(ofp, "SOBJS=", 's', 0);
 258                 } else if (eq(line, "%MACHDEP\n")) {
 259                         do_machdep(ofp);
 260                 } else if (eq(line, "%RULES\n")) {
 261                         do_rules(ofp);
 262                 } else {
 263                         fprintf(stderr,
 264                             "Unknown %% construct in generic makefile: %s",
 265                             line);
 266                 }
 267         }
 268         if (dfp != NULL) {
 269                 copy_dependencies(dfp, ofp);
 270                 (void) fclose(dfp);
 271         }
 272         (void) fclose(ifp);
 273         (void) fclose(ofp);
 274 }
 275
 276 /*
 277  * Read in the information about files used in making the system.
 278  * Store it in the ftab linked list.
 279  */
 280 void
 281 read_files(void)
 282 {
 283         FILE *fp;
 284         struct file_list *tp, *pf;
 285         struct device *dp;
 286         struct opt *op;
 287         const char *wd;
 288         char *this, *needs;
 289         const char *devorprof;
 290         int options;
 291         int not_option;
 292         int for_xnu_lib;
 293         char pname[BUFSIZ];
 294         char fname[1024];
 295         char *rest = (char *) 0;
 296         int nreqs, first = 1, isdup;
 297
 298         ftab = 0;
 299         (void) sprintf(fname, "%s/files", config_directory);
 300 openit:
 301         fp = fopenp(VPATH, fname, pname, "r");
 302         if (fp == 0) {
 303                 perror(fname);
 304                 exit(1);
 305         }
 306 next:
 307         options = 0;
 308         rest = (char *) 0;
 309         /*
 310          * filename     [ standard | optional ]
 311          *      [ dev* | profiling-routine ] [ device-driver]
 312          */
 313         wd = get_word(fp);
 314         if (wd == (char *)EOF) {
 315                 (void) fclose(fp);
 316                 if (first == 1) {
 317                         (void) sprintf(fname, "%s/files.%s", config_directory, machinename);
 318                         first++;
 319                         goto openit;
 320                 }
 321                 return;
 322         }
 323         if (wd == 0) {
 324                 goto next;
 325         }
 326         /*
 327          *  Allow comment lines beginning witha '#' character.
 328          */
 329         if (*wd == '#') {
 330                 while ((wd = get_word(fp)) && wd != (char *)EOF) {
 331                         ;
 332                 }
 333                 goto next;
 334         }
 335
 336         this = ns(wd);
 337         next_word(fp, wd);
 338         if (wd == 0) {
 339                 printf("%s: No type for %s.\n",
 340                     fname, this);
 341                 exit(1);
 342         }
 343         if ((pf = fl_lookup(this)) && (pf->f_type != INVISIBLE || pf->f_flags)) {
 344                 isdup = 1;
 345         } else {
 346                 isdup = 0;
 347         }
 348         tp = 0;
 349         nreqs = 0;
 350         devorprof = "";
 351         needs = 0;
 352         for_xnu_lib = 0;
 353         if (eq(wd, "standard")) {
 354                 goto checkdev;
 355         }
 356         if (!eq(wd, "optional")) {
 357                 printf("%s: %s must be optional or standard\n", fname, this);
 358                 exit(1);
 359         }
 360         if (strncmp(this, "OPTIONS/", 8) == 0) {
 361                 options++;
 362         }
 363         not_option = 0;
 364 nextopt:
 365         next_word(fp, wd);
 366         if (wd == 0) {
 367                 goto doneopt;
 368         }
 369         if (eq(wd, "not")) {
 370                 not_option = !not_option;
 371                 goto nextopt;
 372         }
 373         devorprof = wd;
 374         if (eq(wd, "device-driver") || eq(wd, "profiling-routine")) {
 375                 next_word(fp, wd);
 376                 goto save;
 377         }
 378         if (eq(wd, "xnu-library")) {
 379                 for_xnu_lib = 1;
 380                 goto nextopt;
 381         }
 382         nreqs++;
 383         if (needs == 0 && nreqs == 1) {
 384                 needs = ns(wd);
 385         }
 386         if (isdup) {
 387                 goto invis;
 388         }
 389         if (options) {
 390                 struct opt *lop = 0;
 391                 struct device tdev;
 392
 393                 /*
 394                  *  Allocate a pseudo-device entry which we will insert into
 395                  *  the device list below.  The flags field is set non-zero to
 396                  *  indicate an internal entry rather than one generated from
 397                  *  the configuration file.  The slave field is set to define
 398                  *  the corresponding symbol as 0 should we fail to find the
 399                  *  option in the option list.
 400                  */
 401                 init_dev(&tdev);
 402                 tdev.d_name = ns(wd);
 403                 tdev.d_type = PSEUDO_DEVICE;
 404                 tdev.d_flags++;
 405                 tdev.d_slave = 0;
 406
 407                 for (op = opt; op; lop = op, op = op->op_next) {
 408                         char *od = allCaps(ns(wd));
 409
 410                         /*
 411                          *  Found an option which matches the current device
 412                          *  dependency identifier.  Set the slave field to
 413                          *  define the option in the header file.
 414                          */
 415                         if (strcmp(op->op_name, od) == 0) {
 416                                 tdev.d_slave = 1;
 417                                 if (lop == 0) {
 418                                         opt = op->op_next;
 419                                 } else {
 420                                         lop->op_next = op->op_next;
 421                                 }
 422                                 free(op);
 423                                 op = 0;
 424                         }
 425                         free(od);
 426                         if (op == 0) {
 427                                 break;
 428                         }
 429                 }
 430                 newdev(&tdev);
 431         }
 432         for (dp = dtab; dp != 0; dp = dp->d_next) {
 433                 if (eq(dp->d_name, wd) && (dp->d_type != PSEUDO_DEVICE || dp->d_slave)) {
 434                         if (not_option) {
 435                                 goto invis;     /* dont want file if option present */
 436                         } else {
 437                                 goto nextopt;
 438                         }
 439                 }
 440         }
 441         if (not_option) {
 442                 goto nextopt;           /* want file if option missing */
 443         }
 444         for (op = opt; op != 0; op = op->op_next) {
 445                 if (op->op_value == 0 && opteq(op->op_name, wd)) {
 446                         if (nreqs == 1) {
 447                                 free(needs);
 448                                 needs = 0;
 449                         }
 450                         goto nextopt;
 451                 }
 452         }
 453
 454 invis:
 455         while ((wd = get_word(fp)) != 0) {
 456                 ;
 457         }
 458         if (tp == 0) {
 459                 tp = new_fent();
 460         }
 461         tp->f_fn = this;
 462         tp->f_type = INVISIBLE;
 463         tp->f_needs = needs;
 464         tp->f_flags = isdup;
 465         goto next;
 466
 467 doneopt:
 468         if (nreqs == 0) {
 469                 printf("%s: what is %s optional on?\n",
 470                     fname, this);
 471                 exit(1);
 472         }
 473
 474 checkdev:
 475         if (wd) {
 476                 if (*wd == '|') {
 477                         goto getrest;
 478                 }
 479                 next_word(fp, wd);
 480                 if (wd && eq(wd, "xnu-library")) {
 481                         for_xnu_lib = 1;
 482                         next_word(fp, wd);
 483                 }
 484                 if (wd) {
 485                         devorprof = wd;
 486                         next_word(fp, wd);
 487                 }
 488         }
 489
 490 save:
 491 getrest:
 492         if (wd) {
 493                 if (*wd == '|') {
 494                         rest = ns(get_rest(fp));
 495                 } else {
 496                         printf("%s: syntax error describing %s\n",
 497                             fname, this);
 498                         exit(1);
 499                 }
 500         }
 501         if (eq(devorprof, "profiling-routine") && profiling == 0) {
 502                 goto next;
 503         }
 504         if (tp == 0) {
 505                 tp = new_fent();
 506         }
 507         tp->f_fn = this;
 508         tp->f_extra = rest;
 509         if (options) {
 510                 tp->f_type = INVISIBLE;
 511         } else if (eq(devorprof, "device-driver")) {
 512                 tp->f_type = DRIVER;
 513         } else if (eq(devorprof, "profiling-routine")) {
 514                 tp->f_type = PROFILING;
 515         } else {
 516                 tp->f_type = NORMAL;
 517         }
 518         tp->f_flags = 0;
 519         tp->f_needs = needs;
 520         if (pf && pf->f_type == INVISIBLE) {
 521                 pf->f_flags = 1;                /* mark as duplicate */
 522         }
 523         if (for_xnu_lib) {
 524                 tp->f_flags |= LIBRARYDEP;
 525         }
 526         goto next;
 527 }
 528
 529 int
 530 opteq(const char *cp, const char *dp)
 531 {
 532         char c, d;
 533
 534         for (;; cp++, dp++) {
 535                 if (*cp != *dp) {
 536                         c = isupper(*cp) ? tolower(*cp) : *cp;
 537                         d = isupper(*dp) ? tolower(*dp) : *dp;
 538                         if (c != d) {
 539                                 return 0;
 540                         }
 541                 }
 542                 if (*cp == 0) {
 543                         return 1;
 544                 }
 545         }
 546 }
 547
 548 void
 549 put_source_file_name(FILE *fp, struct file_list *tp)
 550 {
 551         if ((tp->f_fn[0] == '.') && (tp->f_fn[1] == '/')) {
 552                 fprintf(fp, "%s ", tp->f_fn);
 553         } else {
 554                 fprintf(fp, "$(SOURCE_DIR)/%s ", tp->f_fn);
 555         }
 556 }
 557
 558 void
 559 do_objs(FILE *fp, const char *msg, int ext, int flags)
 560 {
 561         struct file_list *tp;
 562         int lpos, len;
 563         char *cp;
 564         char och;
 565         const char *sp;
 566
 567         fprintf(fp, "%s", msg);
 568         lpos = strlen(msg);
 569         for (tp = ftab; tp != 0; tp = tp->f_next) {
 570                 if (tp->f_type == INVISIBLE) {
 571                         continue;
 572                 }
 573
 574                 /*
 575                  * Check flags (if any)
 576                  */
 577                 if (flags && ((tp->f_flags & flags) != flags)) {
 578                         continue;
 579                 }
 580
 581                 /*
 582                  *      Check for '.o' file in list
 583                  */
 584                 cp = tp->f_fn + (len = strlen(tp->f_fn)) - 1;
 585                 if (ext != -1 && *cp != ext) {
 586                         continue;
 587                 } else if (*cp == 'o') {
 588                         if (len + lpos > 72) {
 589                                 lpos = 8;
 590                                 fprintf(fp, "\\\n\t");
 591                         }
 592                         put_source_file_name(fp, tp);
 593                         fprintf(fp, " ");
 594                         lpos += len + 1;
 595                         continue;
 596                 }
 597                 sp = tail(tp->f_fn);
 598                 cp = (char *)sp + (len = strlen(sp)) - 1;
 599                 och = *cp;
 600                 *cp = 'o';
 601                 if (len + lpos > 72) {
 602                         lpos = 8;
 603                         fprintf(fp, "\\\n\t");
 604                 }
 605                 fprintf(fp, "%s ", sp);
 606                 lpos += len + 1;
 607                 *cp = och;
 608         }
 609         putc('\n', fp);
 610 }
 611
 612 void
 613 do_files(FILE *fp, const char *msg, char ext)
 614 {
 615         struct file_list *tp;
 616         int lpos, len = 0; /* dvw: init to 0 */
 617
 618         fprintf(fp, "%s", msg);
 619         lpos = 8;
 620         for (tp = ftab; tp != 0; tp = tp->f_next) {
 621                 if (tp->f_type == INVISIBLE) {
 622                         continue;
 623                 }
 624                 if (tp->f_fn[strlen(tp->f_fn) - 1] != ext) {
 625                         continue;
 626                 }
 627                 /*
 628                  * Always generate a newline.
 629                  * Our Makefile's aren't readable anyway.
 630                  */
 631
 632                 lpos = 8;
 633                 fprintf(fp, "\\\n\t");
 634                 put_source_file_name(fp, tp);
 635                 lpos += len + 1;
 636         }
 637         putc('\n', fp);
 638 }
 639
 640 /*
 641  *  Include machine dependent makefile in output
 642  */
 643
 644 void
 645 do_machdep(FILE *ofp)
 646 {
 647         FILE *ifp;
 648         char pname[BUFSIZ];
 649         char line[BUFSIZ];
 650
 651         (void) sprintf(line, "%s/Makefile.%s", config_directory, machinename);
 652         ifp = fopenp(VPATH, line, pname, "r");
 653         if (ifp == 0) {
 654                 perror(line);
 655                 exit(1);
 656         }
 657         while (fgets(line, BUFSIZ, ifp) != 0) {
 658                 if (profiling && (strncmp(line, "LIBS=", 5) == 0)) {
 659                         fprintf(ofp, "LIBS=${LIBS_P}\n");
 660                 } else {
 661                         fputs(line, ofp);
 662                 }
 663         }
 664         fclose(ifp);
 665 }
 666
 667 const char *
 668 tail(const char *fn)
 669 {
 670         const char *cp;
 671
 672         cp = rindex(fn, '/');
 673         if (cp == 0) {
 674                 return fn;
 675         }
 676         return cp + 1;
 677 }
 678
 679 /*
 680  * Create the makerules for each file
 681  * which is part of the system.
 682  * Devices are processed with the special c2 option -i
 683  * which avoids any problem areas with i/o addressing
 684  * (e.g. for the VAX); assembler files are processed by as.
 685  */
 686 void
 687 do_rules(FILE *f)
 688 {
 689         char *cp;
 690         char *np, och;
 691         const char *tp;
 692         struct file_list *ftp;
 693         const char *extras = ""; /* dvw: init to "" */
 694         char *source_dir;
 695         char och_upper;
 696         const char *nl = "";
 697
 698         for (ftp = ftab; ftp != 0; ftp = ftp->f_next) {
 699                 if (ftp->f_type == INVISIBLE) {
 700                         continue;
 701                 }
 702                 cp = (np = ftp->f_fn) + strlen(ftp->f_fn) - 1;
 703                 och = *cp;
 704                 /*
 705                  *      Don't compile '.o' files
 706                  */
 707                 if (och == 'o') {
 708                         continue;
 709                 }
 710                 /*
 711                  *      Determine where sources should come from
 712                  */
 713                 if ((np[0] == '.') && (np[1] == '/')) {
 714                         source_dir = "";
 715                         np += 2;
 716                 } else {
 717                         source_dir = "$(SOURCE_DIR)/";
 718                 }
 719                 *cp = '\0';
 720                 tp = tail(np);  /* dvw: init tp before 'if' */
 721                 fprintf(f, "-include %sd\n", tp);
 722                 fprintf(f, "%so: %s%s%c\n", tp, source_dir, np, och);
 723                 if (och == 's') {
 724                         fprintf(f, "\t${S_RULE_0}\n");
 725                         fprintf(f, "\t${S_RULE_1A}%s%.*s${S_RULE_1B}%s\n",
 726                             source_dir, (int)(tp - np), np, nl);
 727                         fprintf(f, "\t${S_RULE_2}%s\n", nl);
 728                         continue;
 729                 }
 730                 extras = "";
 731                 switch (ftp->f_type) {
 732                 case NORMAL:
 733                         goto common;
 734                         break;
 735
 736                 case DRIVER:
 737                         extras = "_D";
 738                         goto common;
 739                         break;
 740
 741                 case PROFILING:
 742                         if (!profiling) {
 743                                 continue;
 744                         }
 745                         if (COPTS == 0) {
 746                                 fprintf(stderr,
 747                                     "config: COPTS undefined in generic makefile");
 748                                 COPTS = "";
 749                         }
 750                         extras = "_P";
 751                         goto common;
 752
 753 common:
 754                         och_upper = och + 'A' - 'a';
 755                         fprintf(f, "\t${%c_RULE_0%s}\n", och_upper, extras);
 756                         fprintf(f, "\t${%c_RULE_1A%s}", och_upper, extras);
 757                         if (ftp->f_extra) {
 758                                 fprintf(f, "%s", ftp->f_extra);
 759                         }
 760                         fprintf(f, "%s%.*s${%c_RULE_1B%s}%s\n",
 761                             source_dir, (int)(tp - np), np, och_upper, extras, nl);
 762
 763                         fprintf(f, "\t${%c_RULE_2%s}%s\n", och_upper, extras, nl);
 764                         fprintf(f, "\t${%c_RULE_3%s}%s\n", och_upper, extras, nl);
 765                         fprintf(f, "\t$(if ${%c_RULE_4A%s},${%c_RULE_4A%s}",
 766                             och_upper, extras, och_upper, extras);
 767                         if (ftp->f_extra) {
 768                                 fprintf(f, "%s", ftp->f_extra);
 769                         }
 770                         fprintf(f, "%s%.*s${%c_RULE_4B%s}%s)\n",
 771                             source_dir, (int)(tp - np), np, och_upper, extras, nl);
 772                         break;
 773
 774                 default:
 775                         printf("Don't know rules for %s\n", np);
 776                         break;
 777                 }
 778                 *cp = och;
 779         }
 780 }
 781
 782 char *
 783 allCaps(char *str)
 784 {
 785         char *cp = str;
 786
 787         while (*str) {
 788                 if (islower(*str)) {
 789                         *str = toupper(*str);
 790                 }
 791                 str++;
 792         }
 793         return cp;
 794 }
 795
 796 #define OLDSALUTATION "# DO NOT DELETE THIS LINE"
 797
 798 #define LINESIZE 1024
 799 static char makbuf[LINESIZE];           /* one line buffer for makefile */
 800
 801 void
 802 copy_dependencies(FILE *makin, FILE *makout)
 803 {
 804         int oldlen = (sizeof OLDSALUTATION - 1);
 805
 806         while (fgets(makbuf, LINESIZE, makin) != NULL) {
 807                 if (!strncmp(makbuf, OLDSALUTATION, oldlen)) {
 808                         break;
 809                 }
 810         }
 811         while (fgets(makbuf, LINESIZE, makin) != NULL) {
 812                 if (oldlen != 0) {
 813                         if (makbuf[0] == '\n') {
 814                                 continue;
 815                         } else {
 816                                 oldlen = 0;
 817                         }
 818                 }
 819                 fputs(makbuf, makout);
 820         }
 821 }