break out special local mail processing (e.g., mapping to the

[unix-history] / usr / src / usr.sbin / config / mkmakefile.c

diff --git a/usr/src/usr.sbin/config/mkmakefile.c b/usr/src/usr.sbin/config/mkmakefile.c
index c0a8f59..728a468 100644 (file)
--- a/usr/src/usr.sbin/config/mkmakefile.c
+++ b/usr/src/usr.sbin/config/mkmakefile.c
@@ -1,6 +1,13 @@
+/*
+ * Copyright (c) 1993, 19801990
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ */
+

 #ifndef lint
 #ifndef lint

-static char sccsid[] = "@(#)mkmakefile.c       1.34 (Berkeley) %G%";
-#endif
+static char sccsid[] = "@(#)mkmakefile.c       8.1 (Berkeley) %G%";
+#endif /* not lint */

 
 /*
  * Build the makefile for the system, from
 
 /*
  * Build the makefile for the system, from


@@ -20,12 +27,19 @@ static char sccsid[] = "@(#)mkmakefile.c    1.34 (Berkeley) %G%";
          else \
                wd = word; \
        }
          else \
                wd = word; \
        }

+#define next_quoted_word(fp, wd) \
+       { register char *word = get_quoted_word(fp); \
+         if (word == (char *)EOF) \
+               return; \
+         else \
+               wd = word; \
+       }

 
 static struct file_list *fcur;
 char *tail();
 
 /*
 
 static struct file_list *fcur;
 char *tail();
 
 /*

- * Lookup a file, by make.
+ * Lookup a file, by name.

  */
 struct file_list *
 fl_lookup(file)
  */
 struct file_list *
 fl_lookup(file)


@@ -65,10 +79,7 @@ new_fent()
        register struct file_list *fp;
 
        fp = (struct file_list *) malloc(sizeof *fp);
        register struct file_list *fp;
 
        fp = (struct file_list *) malloc(sizeof *fp);

-       fp->f_needs = 0;
-       fp->f_next = 0;
-       fp->f_flags = 0;
-       fp->f_type = 0;
+       bzero(fp, sizeof *fp);

        if (fcur == 0)
                fcur = ftab = fp;
        else
        if (fcur == 0)
                fcur = ftab = fp;
        else


@@ -77,7 +88,21 @@ new_fent()
        return (fp);
 }
 
        return (fp);
 }
 

-char   *COPTS;
+static struct users {
+       int     u_default;
+       int     u_min;
+       int     u_max;
+} users[] = {
+       { 24, 8, 1024 },                /* MACHINE_VAX */
+       { 4, 2, 128 },                  /* MACHINE_TAHOE */
+       { 8, 2, 64 },                   /* MACHINE_HP300 */
+       { 8, 2, 64 },                   /* MACHINE_I386 */
+       { 8, 2, 64 },                   /* MACHINE_MIPS */
+       { 8, 2, 64 },                   /* MACHINE_PMAX */
+       { 8, 2, 64 },                   /* MACHINE_LUNA68K */
+       { 8, 2, 64 },                   /* MACHINE_NEWS3400 */
+};
+#define        NUSERS  (sizeof (users) / sizeof (users[0]))

 
 /*
  * Build the makefile from the skeleton
 
 /*
  * Build the makefile from the skeleton


@@ -87,18 +112,19 @@ makefile()
        FILE *ifp, *ofp;
        char line[BUFSIZ];
        struct opt *op;
        FILE *ifp, *ofp;
        char line[BUFSIZ];
        struct opt *op;

+       struct users *up;

 
        read_files();
 
        read_files();

-       strcpy(line, "../conf/makefile.");
+       strcpy(line, "Makefile.");

        (void) strcat(line, machinename);
        ifp = fopen(line, "r");
        if (ifp == 0) {
                perror(line);
                exit(1);
        }
        (void) strcat(line, machinename);
        ifp = fopen(line, "r");
        if (ifp == 0) {
                perror(line);
                exit(1);
        }

-       ofp = fopen(path("makefile"), "w");
+       ofp = fopen(path("Makefile"), "w");

        if (ofp == 0) {
        if (ofp == 0) {

-               perror(path("makefile"));
+               perror(path("Makefile"));

                exit(1);
        }
        fprintf(ofp, "IDENT=-D%s", raise(ident));
                exit(1);
        }
        fprintf(ofp, "IDENT=-D%s", raise(ident));


@@ -120,47 +146,35 @@ makefile()
        fprintf(ofp, "\n");
        if (hadtz == 0)
                printf("timezone not specified; gmt assumed\n");
        fprintf(ofp, "\n");
        if (hadtz == 0)
                printf("timezone not specified; gmt assumed\n");

-#ifdef vax
+       if ((unsigned)machine > NUSERS) {
+               printf("maxusers config info isn't present, using vax\n");
+               up = &users[MACHINE_VAX-1];
+       } else
+               up = &users[machine-1];

        if (maxusers == 0) {
        if (maxusers == 0) {

-               printf("maxusers not specified; 24 assumed\n");
-               maxusers = 24;
-       } else if (maxusers < 8) {
-               printf("minimum of 8 maxusers assumed\n");
-               maxusers = 8;
-       } else if (maxusers > 128) {
-               printf("maxusers truncated to 128\n");
-               maxusers = 128;
-       }
-#endif
-       fprintf(ofp, "PARAM=-DTIMEZONE=%d -DDST=%d -DMAXUSERS=%d\n",
-           timezone, dst, maxusers);
+               printf("maxusers not specified; %d assumed\n", up->u_default);
+               maxusers = up->u_default;
+       } else if (maxusers < up->u_min) {
+               printf("minimum of %d maxusers assumed\n", up->u_min);
+               maxusers = up->u_min;
+       } else if (maxusers > up->u_max)
+               printf("warning: maxusers > %d (%d)\n", up->u_max, maxusers);
+       fprintf(ofp, "PARAM=-DTIMEZONE=%d -DDST=%d -DMAXUSERS=%d",
+           zone, dst, maxusers);
+       if (hz > 0)
+               fprintf(ofp, " -DHZ=%d", hz);
+       fprintf(ofp, "\n");
+       for (op = mkopt; op; op = op->op_next)
+               fprintf(ofp, "%s=%s\n", op->op_name, op->op_value);
+       if (debugging)
+               fprintf(ofp, "DEBUG=-g\n");
+       if (profiling)
+               fprintf(ofp, "PROF=-pg\n");

        while (fgets(line, BUFSIZ, ifp) != 0) {
        while (fgets(line, BUFSIZ, ifp) != 0) {

-               if (*line == '%')
-                       goto percent;
-               if (profiling && strncmp(line, "COPTS=", 6) == 0) {
-                       register char *cp;
-
-                       fprintf(ofp, 
-                           "GPROF.EX=/usr/src/lib/libc/%s/csu/gmon.ex\n",
-                           machinename);
-                       cp = index(line, '\n');
-                       if (cp)
-                               *cp = 0;
-                       cp = line + 6;
-                       while (*cp && (*cp == ' ' || *cp == '\t'))
-                               cp++;
-                       COPTS = malloc((unsigned)(strlen(cp) + 1));
-                       if (COPTS == 0) {
-                               printf("config: out of memory\n");
-                               exit(1);
-                       }
-                       strcpy(COPTS, cp);
-                       fprintf(ofp, "%s -pg\n", line);
+               if (*line != '%') {
+                       fprintf(ofp, "%s", line);

                        continue;
                }
                        continue;
                }

-               fprintf(ofp, "%s", line);
-               continue;
-       percent:

                if (eq(line, "%OBJS\n"))
                        do_objs(ofp);
                else if (eq(line, "%CFILES\n"))
                if (eq(line, "%OBJS\n"))
                        do_objs(ofp);
                else if (eq(line, "%CFILES\n"))


@@ -185,14 +199,16 @@ makefile()
 read_files()
 {
        FILE *fp;
 read_files()
 {
        FILE *fp;

-       register struct file_list *tp;
+       register struct file_list *tp, *pf;

        register struct device *dp;
        register struct device *dp;

-       char *wd, *this, *needs, *devorprof;
+       struct device *save_dp;
+       register struct opt *op;
+       char *wd, *this, *needs, *special;

        char fname[32];
        char fname[32];

-       int nreqs, first = 1, configdep;
+       int nreqs, first = 1, configdep, isdup, std, filetype;

 
        ftab = 0;
 
        ftab = 0;

-       (void) strcpy(fname, "files");
+       (void) strcpy(fname, "../../conf/files");

 openit:
        fp = fopen(fname, "r");
        if (fp == 0) {
 openit:
        fp = fopen(fname, "r");
        if (fp == 0) {


@@ -203,6 +219,7 @@ next:
        /*
         * filename     [ standard | optional ] [ config-dependent ]
         *      [ dev* | profiling-routine ] [ device-driver]
        /*
         * filename     [ standard | optional ] [ config-dependent ]
         *      [ dev* | profiling-routine ] [ device-driver]

+        *      [ compile-with "compile rule" ]

         */
        wd = get_word(fp);
        if (wd == (char *)EOF) {
         */
        wd = get_word(fp);
        if (wd == (char *)EOF) {


@@ -230,44 +247,82 @@ next:
                    fname, this);
                exit(1);
        }
                    fname, this);
                exit(1);
        }

-       if (fl_lookup(this)) {
-               printf("%s: Duplicate file %s.\n",
-                   fname, this);
-               exit(1);
-       }
+       if ((pf = fl_lookup(this)) && (pf->f_type != INVISIBLE || pf->f_flags))
+               isdup = 1;
+       else
+               isdup = 0;

        tp = 0;
        if (first == 3 && (tp = fltail_lookup(this)) != 0)
                printf("%s: Local file %s overrides %s.\n",
                    fname, this, tp->f_fn);
        nreqs = 0;
        tp = 0;
        if (first == 3 && (tp = fltail_lookup(this)) != 0)
                printf("%s: Local file %s overrides %s.\n",
                    fname, this, tp->f_fn);
        nreqs = 0;

-       devorprof = "";
+       special = 0;

        configdep = 0;
        needs = 0;
        configdep = 0;
        needs = 0;

+       std = 0;
+       filetype = NORMAL;

        if (eq(wd, "standard"))
        if (eq(wd, "standard"))

-               goto checkdev;
-       if (!eq(wd, "optional")) {
+               std = 1;
+       else if (!eq(wd, "optional")) {

                printf("%s: %s must be optional or standard\n", fname, this);
                exit(1);
        }
                printf("%s: %s must be optional or standard\n", fname, this);
                exit(1);
        }

-nextopt:
+nextparam:

        next_word(fp, wd);
        if (wd == 0)
        next_word(fp, wd);
        if (wd == 0)

-               goto doneopt;
+               goto doneparam;

        if (eq(wd, "config-dependent")) {
                configdep++;
        if (eq(wd, "config-dependent")) {
                configdep++;

-               goto nextopt;
+               goto nextparam;

        }
        }

-       devorprof = wd;
-       if (eq(wd, "device-driver") || eq(wd, "profiling-routine")) {
-               next_word(fp, wd);
-               goto save;
+       if (eq(wd, "compile-with")) {
+               next_quoted_word(fp, wd);
+               if (wd == 0) {
+                       printf("%s: %s missing compile command string.\n",
+                              fname);
+                       exit(1);
+               }
+               special = ns(wd);
+               goto nextparam;

        }
        nreqs++;
        }
        nreqs++;

-       if (needs == 0)
+       if (eq(wd, "device-driver")) {
+               filetype = DRIVER;
+               goto nextparam;
+       }
+       if (eq(wd, "profiling-routine")) {
+               filetype = PROFILING;
+               goto nextparam;
+       }
+       if (needs == 0 && nreqs == 1)

                needs = ns(wd);
                needs = ns(wd);

-       for (dp = dtab; dp != 0; dp = dp->d_next)
-               if (eq(dp->d_name, wd))
-                       goto nextopt;
+       if (isdup)
+               goto invis;
+       for (dp = dtab; dp != 0; save_dp = dp, dp = dp->d_next)
+               if (eq(dp->d_name, wd)) {
+                       if (std && dp->d_type == PSEUDO_DEVICE &&
+                           dp->d_slave <= 0)
+                               dp->d_slave = 1;
+                       goto nextparam;
+               }
+       if (std) {
+               dp = (struct device *) malloc(sizeof *dp);
+               init_dev(dp);
+               dp->d_name = ns(wd);
+               dp->d_type = PSEUDO_DEVICE;
+               dp->d_slave = 1;
+               save_dp->d_next = dp;
+               goto nextparam;
+       }
+       for (op = opt; op != 0; op = op->op_next)
+               if (op->op_value == 0 && opteq(op->op_name, wd)) {
+                       if (nreqs == 1) {
+                               free(needs);
+                               needs = 0;
+                       }
+                       goto nextparam;
+               }
+invis:

        while ((wd = get_word(fp)) != 0)
                ;
        if (tp == 0)
        while ((wd = get_word(fp)) != 0)
                ;
        if (tp == 0)


@@ -275,52 +330,56 @@ nextopt:
        tp->f_fn = this;
        tp->f_type = INVISIBLE;
        tp->f_needs = needs;
        tp->f_fn = this;
        tp->f_type = INVISIBLE;
        tp->f_needs = needs;

+       tp->f_flags = isdup;
+       tp->f_special = special;

        goto next;
 
        goto next;
 

-doneopt:
-       if (nreqs == 0) {
+doneparam:
+       if (std == 0 && nreqs == 0) {

                printf("%s: what is %s optional on?\n",
                    fname, this);
                exit(1);
        }
 
                printf("%s: what is %s optional on?\n",
                    fname, this);
                exit(1);
        }
 

-checkdev:
-       if (wd) {
-               next_word(fp, wd);
-               if (wd) {
-                       if (eq(wd, "config-dependent")) {
-                               configdep++;
-                               goto checkdev;
-                       }
-                       devorprof = wd;
-                       next_word(fp, wd);
-               }
-       }
-

 save:
        if (wd) {
                printf("%s: syntax error describing %s\n",
                    fname, this);
                exit(1);
        }
 save:
        if (wd) {
                printf("%s: syntax error describing %s\n",
                    fname, this);
                exit(1);
        }

-       if (eq(devorprof, "profiling-routine") && profiling == 0)
+       if (filetype == PROFILING && profiling == 0)

                goto next;
        if (tp == 0)
                tp = new_fent();
        tp->f_fn = this;
                goto next;
        if (tp == 0)
                tp = new_fent();
        tp->f_fn = this;

-       if (eq(devorprof, "device-driver"))
-               tp->f_type = DRIVER;
-       else if (eq(devorprof, "profiling-routine"))
-               tp->f_type = PROFILING;
-       else
-               tp->f_type = NORMAL;
+       tp->f_type = filetype;

        tp->f_flags = 0;
        if (configdep)
                tp->f_flags |= CONFIGDEP;
        tp->f_needs = needs;
        tp->f_flags = 0;
        if (configdep)
                tp->f_flags |= CONFIGDEP;
        tp->f_needs = needs;

+       tp->f_special = special;
+       if (pf && pf->f_type == INVISIBLE)
+               pf->f_flags = 1;                /* mark as duplicate */

        goto next;
 }
 
        goto next;
 }
 

+opteq(cp, dp)
+       char *cp, *dp;
+{
+       char c, d;
+
+       for (; ; cp++, dp++) {
+               if (*cp != *dp) {
+                       c = isupper(*cp) ? tolower(*cp) : *cp;
+                       d = isupper(*dp) ? tolower(*dp) : *dp;
+                       if (c != d)
+                               return (0);
+               }
+               if (*cp == 0)
+                       return (1);
+       }
+}
+

 do_objs(fp)
        FILE *fp;
 {
 do_objs(fp)
        FILE *fp;
 {


@@ -338,7 +397,7 @@ do_objs(fp)
                for (fl = conf_list; fl; fl = fl->f_next) {
                        if (fl->f_type != SWAPSPEC)
                                continue;
                for (fl = conf_list; fl; fl = fl->f_next) {
                        if (fl->f_type != SWAPSPEC)
                                continue;

-                       sprintf(swapname, "swap%s.c", fl->f_fn);
+                       (void) sprintf(swapname, "swap%s.c", fl->f_fn);

                        if (eq(sp, swapname))
                                goto cont;
                }
                        if (eq(sp, swapname))
                                goto cont;
                }


@@ -362,23 +421,38 @@ cont:
 do_cfiles(fp)
        FILE *fp;
 {
 do_cfiles(fp)
        FILE *fp;
 {

-       register struct file_list *tp;
+       register struct file_list *tp, *fl;

        register int lpos, len;
        register int lpos, len;

+       char swapname[32];

 
 

-       fprintf(fp, "CFILES=");
+       fputs("CFILES=", fp);

        lpos = 8;
        lpos = 8;

-       for (tp = ftab; tp != 0; tp = tp->f_next) {
-               if (tp->f_type == INVISIBLE)
-                       continue;
-               if (tp->f_fn[strlen(tp->f_fn)-1] != 'c')
-                       continue;
-               if ((len = 3 + strlen(tp->f_fn)) + lpos > 72) {
-                       lpos = 8;
-                       fprintf(fp, "\\\n\t");
+       for (tp = ftab; tp; tp = tp->f_next)
+               if (tp->f_type != INVISIBLE) {
+                       len = strlen(tp->f_fn);
+                       if (tp->f_fn[len - 1] != 'c')
+                               continue;
+                       if ((len = 3 + len) + lpos > 72) {
+                               lpos = 8;
+                               fputs("\\\n\t", fp);
+                       }
+                       fprintf(fp, "$S/%s ", tp->f_fn);
+                       lpos += len + 1;
+               }
+       for (fl = conf_list; fl; fl = fl->f_next)
+               if (fl->f_type == SYSTEMSPEC) {
+                       (void) sprintf(swapname, "swap%s.c", fl->f_fn);
+                       if ((len = 3 + strlen(swapname)) + lpos > 72) {
+                               lpos = 8;
+                               fputs("\\\n\t", fp);
+                       }
+                       if (eq(fl->f_fn, "generic"))
+                               fprintf(fp, "$S/%s/%s/%s ",
+                                   machinename, machinename, swapname);
+                       else
+                               fprintf(fp, "%s ", swapname);
+                       lpos += len + 1;

                }
                }

-               fprintf(fp, "../%s ", tp->f_fn);
-               lpos += len + 1;
-       }

        if (lpos != 8)
                putc('\n', fp);
 }
        if (lpos != 8)
                putc('\n', fp);
 }


@@ -407,87 +481,52 @@ do_rules(f)
 {
        register char *cp, *np, och, *tp;
        register struct file_list *ftp;
 {
        register char *cp, *np, och, *tp;
        register struct file_list *ftp;

-       char *extras;
-
-for (ftp = ftab; ftp != 0; ftp = ftp->f_next) {
-       if (ftp->f_type == INVISIBLE)
-               continue;
-       cp = (np = ftp->f_fn) + strlen(ftp->f_fn) - 1;
-       och = *cp;
-       *cp = '\0';
-       fprintf(f, "%so: ../%s%c\n", tail(np), np, och);
-       tp = tail(np);
-       if (och == 's') {
-               fprintf(f, "\t-ln -s ../%ss %sc\n", np, tp);
-               fprintf(f, "\t${CC} -E ${COPTS} %sc | ${AS} -o %so\n",
-                       tp, tp);
-               fprintf(f, "\trm -f %sc\n\n", tp);
-               continue;
-       }
-       if (ftp->f_flags & CONFIGDEP)
-               extras = "${PARAM} ";
-       else
-               extras = "";
-       switch (ftp->f_type) {
-
-       case NORMAL:
-               switch (machine) {
-
-               case MACHINE_VAX:
-                       fprintf(f, "\t${CC} -c -S ${COPTS} %s../%sc\n",
-                               extras, np);
-                       fprintf(f, "\t${C2} %ss | ../%s/inline/inline |",
-                           tp, machinename);
-                       fprintf(f, " ${AS} -o %so\n", tp);
-                       fprintf(f, "\trm -f %ss\n\n", tp);
-                       break;
-
-               }
-               break;
-
-       case DRIVER:
-               switch (machine) {
-
-               case MACHINE_VAX:
-                       fprintf(f, "\t${CC} -c -S ${COPTS} %s../%sc\n",
-                               extras, np);
-                       fprintf(f,"\t${C2} -i %ss | ../%s/inline/inline |",
-                           tp, machinename);
-                       fprintf(f, " ${AS} -o %so\n", tp);
-                       fprintf(f, "\trm -f %ss\n\n", tp);
-                       break;
-
-               }
-               break;
+       char *special;

 
 

-       case PROFILING:
-               if (!profiling)
+       for (ftp = ftab; ftp != 0; ftp = ftp->f_next) {
+               if (ftp->f_type == INVISIBLE)
+                       continue;
+               cp = (np = ftp->f_fn) + strlen(ftp->f_fn) - 1;
+               och = *cp;
+               *cp = '\0';
+               if (och == 'o') {
+                       fprintf(f, "%so:\n\t-cp $S/%so .\n\n", tail(np), np);

                        continue;
                        continue;

-               if (COPTS == 0) {
-                       fprintf(stderr,
-                           "config: COPTS undefined in generic makefile");
-                       COPTS = "";

                }
                }

-               switch (machine) {
-
-               case MACHINE_VAX:
-                       fprintf(f, "\t${CC} -c -S %s %s../%sc\n",
-                               COPTS, extras, np);
-                       fprintf(f, "\tex - %ss < ${GPROF.EX}\n", tp);
-                       fprintf(f, "\t../%s/inline/inline %ss | ${AS} -o %so\n",
-                           machinename, tp, tp);
-                       fprintf(f, "\trm -f %ss\n\n", tp);
-                       break;
-
+               fprintf(f, "%so: $S/%s%c\n", tail(np), np, och);
+               tp = tail(np);
+               special = ftp->f_special;
+               if (special == 0) {
+                       char *ftype;
+                       static char cmd[128];
+
+                       switch (ftp->f_type) {
+
+                       case NORMAL:
+                               ftype = "NORMAL";
+                               break;
+
+                       case DRIVER:
+                               ftype = "DRIVER";
+                               break;
+
+                       case PROFILING:
+                               if (!profiling)
+                                       continue;
+                               ftype = "PROFILE";
+                               break;
+
+                       default:
+                               printf("config: don't know rules for %s\n", np);
+                               break;
+                       }
+                       (void)sprintf(cmd, "${%s_%c%s}", ftype, toupper(och),
+                                     ftp->f_flags & CONFIGDEP? "_C" : "");
+                       special = cmd;

                }
                }

-               break;
-
-       default:
-               printf("Don't know rules for %s\n", np);
-               break;
+               *cp = och;
+               fprintf(f, "\t%s\n\n", special);

        }
        }

-       *cp = och;
-}

 }
 
 /*
 }
 
 /*


@@ -497,24 +536,17 @@ do_load(f)
        register FILE *f;
 {
        register struct file_list *fl;
        register FILE *f;
 {
        register struct file_list *fl;

-       int first = 1;
+       register int first;

        struct file_list *do_systemspec();
 
        struct file_list *do_systemspec();
 

-       fl = conf_list;
-       while (fl) {
-               if (fl->f_type != SYSTEMSPEC) {
-                       fl = fl->f_next;
-                       continue;
-               }
-               fl = do_systemspec(f, fl, first);
-               if (first)
-                       first = 0;
-       }
-       fprintf(f, "all:");
-       for (fl = conf_list; fl != 0; fl = fl->f_next)
+       for (first = 1, fl = conf_list; fl; first = 0)
+               fl = fl->f_type == SYSTEMSPEC ?
+                       do_systemspec(f, fl, first) : fl->f_next;
+       fputs("all:", f);
+       for (fl = conf_list; fl; fl = fl->f_next)

                if (fl->f_type == SYSTEMSPEC)
                        fprintf(f, " %s", fl->f_needs);
                if (fl->f_type == SYSTEMSPEC)
                        fprintf(f, " %s", fl->f_needs);

-       fprintf(f, "\n");
+       putc('\n', f);

 }
 
 struct file_list *
 }
 
 struct file_list *


@@ -524,34 +556,16 @@ do_systemspec(f, fl, first)
        int first;
 {
 
        int first;
 {
 

-       fprintf(f, "%s: makefile", fl->f_needs);
-       if (machine == MACHINE_VAX)
-               fprintf(f, " ../%s/inline/inline", machinename);
-       fprintf(f, " locore.o ${OBJS} param.o ioconf.o swap%s.o\n", fl->f_fn);
-       fprintf(f, "\t@echo loading %s\n\t@rm -f %s\n",
-           fl->f_needs, fl->f_needs);
-       if (first) {
-               fprintf(f, "\t@sh ../conf/newvers.sh\n");
-               fprintf(f, "\t@${CC} $(CFLAGS) -c vers.c\n");
-       }
-       switch (machine) {
-
-       case MACHINE_VAX:
-               fprintf(f, "\t@${LD} -n -o %s -e start -x -T 80000000 ",
-                       fl->f_needs);
-               break;
-
-       }
-       fprintf(f, "locore.o ${OBJS} vers.o ioconf.o param.o ");
-       fprintf(f, "swap%s.o\n", fl->f_fn);
-       fprintf(f, "\t@echo rearranging symbols\n");
-       fprintf(f, "\t@-symorder ../%s/symbols.sort %s\n",
-           machinename, fl->f_needs);
-       fprintf(f, "\t@size %s\n", fl->f_needs);
-       fprintf(f, "\t@chmod 755 %s\n\n", fl->f_needs);
+       fprintf(f, "%s: ${SYSTEM_DEP} swap%s.o", fl->f_needs, fl->f_fn);
+       if (first)
+               fprintf(f, " newvers");
+       fprintf(f, "\n\t${SYSTEM_LD_HEAD}\n");
+       fprintf(f, "\t${SYSTEM_LD} swap%s.o\n", fl->f_fn);
+       fprintf(f, "\t${SYSTEM_LD_TAIL}\n\n");

        do_swapspec(f, fl->f_fn);
        do_swapspec(f, fl->f_fn);

-       for (fl = fl->f_next; fl->f_type == SWAPSPEC; fl = fl->f_next)
-               ;
+       for (fl = fl->f_next; fl; fl = fl->f_next)
+               if (fl->f_type != SWAPSPEC)
+                       break;

        return (fl);
 }
 
        return (fl);
 }
 


@@ -560,24 +574,12 @@ do_swapspec(f, name)
        register char *name;
 {
 
        register char *name;
 {
 

-       if (!eq(name, "generic")) {
+       if (!eq(name, "generic"))

                fprintf(f, "swap%s.o: swap%s.c\n", name, name);
                fprintf(f, "swap%s.o: swap%s.c\n", name, name);

-               fprintf(f, "\t${CC} -c -O ${COPTS} swap%s.c\n\n", name);
-               return;
-       }
-       fprintf(f, "swapgeneric.o: ../%s/swapgeneric.c\n", machinename);
-       switch (machine) {
-
-       case MACHINE_VAX:
-               fprintf(f, "\t${CC} -c -S ${COPTS} ");
-               fprintf(f, "../%s/swapgeneric.c\n", machinename);
-               fprintf(f, "\t${C2} swapgeneric.s | ");
-               fprintf(f, "../%s/inline/inline", machinename);
-               fprintf(f, " | ${AS} -o swapgeneric.o\n");
-               fprintf(f, "\trm -f swapgeneric.s\n\n");
-               break;
-
-       }
+       else
+               fprintf(f, "swapgeneric.o: $S/%s/%s/swapgeneric.c\n",
+                       machinename, machinename);
+       fprintf(f, "\t${NORMAL_C}\n\n");

 }
 
 char *
 }
 
 char *