Initial revision

1 files changed, 327 insertions, 0 deletions

diff --git a/default.c b/default.c
new file mode 100644
index 00000000..495603e1
--- /dev/null
+++ b/default.c
@@ -0,0 +1,327 @@
+/* Data base of default implicit rules for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Make is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Make; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "make.h"
+#include "rule.h"
+#include "dep.h"
+#include "file.h"
+#include "commands.h"
+#include "variable.h"
+
+
+/* This is the default list of suffixes for suffix rules.
+   `.s' must come last, so that a `.o' file will be made from
+   a `.c' or `.p' or ... file rather than from a .s file.  */
+
+static char default_suffixes[]
+  = ".out .a .ln .o .c .cc .C .p .f .F .r .y .l .s .S \
+.mod .sym .def .h .info .dvi .tex .texinfo .texi .cweb .web .sh .elc .el";
+
+static struct pspec default_pattern_rules[] =
+  {
+    "(%)", "%",
+    "$(AR) $(ARFLAGS) $@ $<",
+
+    /* The X.out rules are only in BSD's default set because
+       BSD Make has no null-suffix rules, so `foo.out' and
+       `foo' are the same thing.  */
+    "%.out", "%",
+    "@rm -f $@ \n cp $< $@",
+
+    0, 0, 0
+  };
+
+static struct pspec default_terminal_rules[] =
+  {
+    /* RCS.  */
+    "%", "%,v",
+    "test -f $@ || $(CO) $(COFLAGS) $< $@",
+    "%", "RCS/%,v",
+    "test -f $@ || $(CO) $(COFLAGS) $< $@",
+
+    /* SCCS.  */
+    "%", "s.%",
+    "$(GET) $(GFLAGS) $<",
+    "%", "SCCS/s.%",
+    "$(GET) $(GFLAGS) $<",
+
+    0, 0, 0
+  };
+
+static char *default_suffix_rules[] =
+  {
+    ".o",
+    "$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".s",
+    "$(LINK.s) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".S",
+    "$(LINK.S) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".c",
+    "$(LINK.c) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".cc",
+    "$(LINK.cc) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".C",
+    "$(LINK.C) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".f",
+    "$(LINK.f) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".p",
+    "$(LINK.p) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".F",
+    "$(LINK.F) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".r",
+    "$(LINK.r) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".mod",
+    "$(COMPILE.mod) -o $@ -e $@ $^",
+
+    ".def.sym", 
+    "$(COMPILE.def) -o $@ $<",
+
+    ".sh",
+    "cat $< >$@ \n chmod a+x $@",
+
+    ".s.o",
+#if !defined(M_XENIX) || defined(__GNUC__)
+    "$(COMPILE.s) -o $@ $<",
+#else	/* Xenix.  */
+    "$(COMPILE.s) -o$@ $<",
+#endif	/* Not Xenix.  */
+    ".S.o",
+#if !defined(M_XENIX) || defined(__GNUC__)
+    "$(COMPILE.S) -o $@ $<",
+#else	/* Xenix.  */
+    "$(COMPILE.S) -o$@ $<",
+#endif	/* Not Xenix.  */
+    ".c.o",
+    "$(COMPILE.c) $< $(OUTPUT_OPTION)",
+    ".cc.o",
+    "$(COMPILE.cc) $< $(OUTPUT_OPTION)",
+    ".C.o",
+    "$(COMPILE.C) $< $(OUTPUT_OPTION)",
+    ".f.o",
+    "$(COMPILE.f) $< $(OUTPUT_OPTION)",
+    ".p.o",
+    "$(COMPILE.p) $< $(OUTPUT_OPTION)",
+    ".F.o",
+    "$(COMPILE.F) $< $(OUTPUT_OPTION)",
+    ".r.o",
+    "$(COMPILE.r) $< $(OUTPUT_OPTION)",
+    ".mod.o",
+    "$(COMPILE.mod) -o $@ $<",
+
+    ".c.ln",
+    "$(LINT.c) -C$* $<",
+    ".y.ln",
+    "$(YACC.y) $< \n $(LINT.c) -C$* y.tab.c \n $(RM) y.tab.c",
+    ".l.ln",
+    "@$(RM) $*.c \n $(LEX.l) $< > $*.c \n\
+$(LINT.c) -i $*.c -o $@ \n $(RM) $*.c",
+
+    ".y.c",
+    "$(YACC.y) $< \n mv -f y.tab.c $@",
+    ".l.c",
+    "@$(RM) $@ \n $(LEX.l) $< > $@",
+
+    ".F.f",
+    "$(PREPROCESS.F) $< $(OUTPUT_OPTION)",
+    ".r.f",
+    "$(PREPROCESS.r) $< $(OUTPUT_OPTION)",
+
+    /* This might actually make lex.yy.c if there's no %R%
+       directive in $*.l, but in that case why were you
+       trying to make $*.r anyway?  */
+    ".l.r",
+    "$(LEX.l) $< > $@ \n mv -f lex.yy.r $@",
+
+    ".S.s",
+    "$(PREPROCESS.S) $< > $@",
+
+    ".texinfo.info",
+    "$(MAKEINFO) $<",
+
+    ".texi.info",
+    "$(MAKEINFO) $<",
+
+    ".tex.dvi",
+    "$(TEX) $<",
+
+    ".texinfo.dvi",
+    "$(TEXI2DVI) $<",
+
+    ".texi.dvi",
+    "$(TEXI2DVI) $<",
+
+    ".cweb.c",
+    "$(CTANGLE) $<",
+
+    ".web.p",
+    "$(TANGLE) $<",
+
+    ".cweb.tex",
+    "$(CWEAVE) $<",
+
+    ".web.tex",
+    "$(WEAVE) $<",
+
+    0}
+;
+
+static char *default_variables[] =
+  {
+    "AR", "ar",
+    "ARFLAGS", "rv",
+    "AS", "as",
+    "CC", "cc",
+    "C++", "g++",
+    "CO", "co",
+    "CPP", "$(CC) -E",
+#ifdef	_IBMR2
+    "FC", "xlf",
+#else
+    "FC", "f77",
+#endif
+    /* System V uses these, so explicit rules using them should work.
+       However, there is no way to make implicit rules use them and FC.  */
+    "F77", "$(FC)",
+    "F77FLAGS", "$(FFLAGS)",
+#ifdef	USG
+    "GET", "get",
+#else
+    "GET", "/usr/sccs/get",
+#endif
+    "LD", "ld",
+    "LEX", "lex",
+    "LINT", "lint",
+    "M2C", "m2c",
+#ifdef	pyr
+    "PC", "pascal",
+#else
+    "PC", "pc",
+#endif
+    "YACC", "yacc",	/* Or "bison -y"  */
+    "MAKEINFO", "makeinfo",
+    "TEX", "tex",
+    "TEXI2DVI", "texi2dvi",
+    "WEAVE", "weave",
+    "CWEAVE", "cweave",
+    "TANGLE", "tangle",
+    "CTANGLE", "ctangle",
+
+    "RM", "rm -f",
+
+    "LINK.o", "$(CC) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.cc", "$(C++) $(C++FLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "COMPILE.C", "$(COMPILE.cc)",
+    "LINK.cc", "$(C++) $(C++FLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "LINK.C", "$(LINK.cc)",
+    "YACC.y", "$(YACC) $(YFLAGS)",
+    "LEX.l", "$(LEX) $(LFLAGS) -t",
+    "COMPILE.f", "$(FC) $(FFLAGS) $(TARGET_ARCH) -c",
+    "LINK.f", "$(FC) $(FFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -c",
+    "LINK.r", "$(FC) $(FFLAGS) $(RFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.def", "$(M2C) $(M2FLAGS) $(DEFFLAGS) $(TARGET_ARCH)",
+    "COMPILE.mod", "$(M2C) $(M2FLAGS) $(MODFLAGS) $(TARGET_ARCH)",
+    "COMPILE.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "LINK.s", "$(CC) $(ASFLAGS) $(LDFLAGS) $(TARGET_MACH)",
+    "COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)",
+    "LINK.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_MACH)",
+    "COMPILE.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_MACH) -c",
+#if !defined(M_XENIX) || defined(__GNUC__)
+    "PREPROCESS.S", "$(CC) -E $(CPPFLAGS)",
+#else	/* Xenix.  */
+    "PREPROCESS.S", "$(CC) -EP $(CPPFLAGS)",
+#endif	/* Not Xenix.  */
+    "PREPROCESS.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -F",
+    "PREPROCESS.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -F",
+    "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
+
+#ifndef	NO_MINUS_C_MINUS_O
+#if !defined(M_XENIX) || defined(__GNUC__)
+    "OUTPUT_OPTION", "-o $@",
+#else	/* Xenix.  */
+    "OUTPUT_OPTION", "-Fo$@",
+#endif	/* Not Xenix.  */
+#endif
+
+    0, 0
+  };
+
+/* Set up the default .SUFFIXES list.  */
+
+void
+set_default_suffixes ()
+{
+  suffix_file = enter_file (".SUFFIXES");
+
+  if (no_builtin_rules_flag)
+    (void) define_variable ("SUFFIXES", 8, "", o_default, 0);
+  else
+    {
+      char *p = default_suffixes;
+      suffix_file->deps = (struct dep *)
+	multi_glob (parse_file_seq (&p, '\0', sizeof (struct dep), 1),
+		    sizeof (struct dep));
+      (void) define_variable ("SUFFIXES", 8, default_suffixes, o_default, 0);
+    }
+}
+
+/* Install the default pattern rules and enter
+   the default suffix rules as file rules.  */
+
+void
+install_default_implicit_rules ()
+{
+  register struct pspec *p;
+  register char **s;
+  
+  if (no_builtin_rules_flag)
+    return;
+
+  for (p = default_pattern_rules; p->target != 0; ++p)
+    install_pattern_rule (p, 0);
+
+  for (p = default_terminal_rules; p->target != 0; ++p)
+    install_pattern_rule (p, 1);
+
+  for (s = default_suffix_rules; *s != 0; s += 2)
+    {
+      register struct file *f = enter_file (s[0]);
+      /* Don't clobber cmds given in a makefile if there were any.  */
+      if (f->cmds == 0)
+	{
+	  f->cmds = (struct commands *) xmalloc (sizeof (struct commands));
+	  f->cmds->filename = 0;
+	  f->cmds->commands = s[1];
+	  f->cmds->command_lines = 0;
+	}
+    }
+}
+
+void
+define_default_variables ()
+{
+  register char **s;
+
+  for (s = default_variables; *s != 0; s += 2)
+    (void) define_variable (s[0], strlen (s[0]), s[1], o_default, 1);
+}