--- /dev/null
+# UGH. GNU make comes with implicit rules.
+# We don't want any of them, and can't force users to run
+# --no-builtin-rules
+
+.SUFFIXES:
+
+#Compiling C programs
+# `N.o' is made automatically from `N.c' with a command of the form
+# `$(CC) -c $(CPPFLAGS) $(CFLAGS)'.
+
+%.o: %.c
+
+# Compiling C++ programs
+# `N.o' is made automatically from `N.cc' or `N.C' with a command of
+# the form `$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)'. We encourage you to
+# use the suffix `.cc' for C++ source files instead of `.C'.
+
+%.o: %.cc
+
+# Compiling Pascal programs
+# `N.o' is made automatically from `N.p' with the command `$(PC) -c
+# $(PFLAGS)'.
+
+%.o: %.p
+
+# Compiling Fortran and Ratfor programs
+# `N.o' is made automatically from `N.r', `N.F' or `N.f' by running
+# the Fortran compiler. The precise command used is as follows:
+
+# `.f'
+# `$(FC) -c $(FFLAGS)'.
+
+%.o: %.f
+
+# `.F'
+# `$(FC) -c $(FFLAGS) $(CPPFLAGS)'.
+
+%.o: %.F
+
+# `.r'
+# `$(FC) -c $(FFLAGS) $(RFLAGS)'.
+
+%.o: %.r
+
+# Preprocessing Fortran and Ratfor programs
+# `N.f' is made automatically from `N.r' or `N.F'. This rule runs
+# just the preprocessor to convert a Ratfor or preprocessable
+# Fortran program into a strict Fortran program. The precise
+# command used is as follows:
+
+# `.F'
+# `$(FC) -F $(CPPFLAGS) $(FFLAGS)'.
+
+%.f: %.F
+
+# `.r'
+# `$(FC) -F $(FFLAGS) $(RFLAGS)'.
+
+%.f: %.r
+
+# Compiling Modula-2 programs
+# `N.sym' is made from `N.def' with a command of the form `$(M2C)
+# $(M2FLAGS) $(DEFFLAGS)'. `N.o' is made from `N.mod'; the form is:
+# `$(M2C) $(M2FLAGS) $(MODFLAGS)'.
+
+%.sym: %.def
+%.o: %.mod
+
+# Assembling and preprocessing assembler programs
+# `N.o' is made automatically from `N.s' by running the assembler,
+# `as'. The precise command is `$(AS) $(ASFLAGS)'.
+
+%.o: %.s
+
+# `N.s' is made automatically from `N.S' by running the C
+# preprocessor, `cpp'. The precise command is `$(CPP) $(CPPFLAGS)'.
+
+%.s: %.S
+
+# Linking a single object file
+# `N' is made automatically from `N.o' by running the linker
+# (usually called `ld') via the C compiler. The precise command
+# used is `$(CC) $(LDFLAGS) N.o $(LOADLIBES) $(LDLIBS)'.
+
+%: %.o
+
+# This rule does the right thing for a simple program with only one
+# source file. It will also do the right thing if there are multiple
+# object files (presumably coming from various other source files),
+# one of which has a name matching that of the executable file.
+# Thus,
+
+# x: y.o z.o
+
+# when `x.c', `y.c' and `z.c' all exist will execute:
+
+# cc -c x.c -o x.o
+# cc -c y.c -o y.o
+# cc -c z.c -o z.o
+# cc x.o y.o z.o -o x
+# rm -f x.o
+# rm -f y.o
+# rm -f z.o
+
+# In more complicated cases, such as when there is no object file
+# whose name derives from the executable file name, you must write
+# an explicit command for linking.
+
+# Each kind of file automatically made into `.o' object files will
+# be automatically linked by using the compiler (`$(CC)', `$(FC)' or
+# `$(PC)'; the C compiler `$(CC)' is used to assemble `.s' files)
+# without the `-c' option. This could be done by using the `.o'
+# object files as intermediates, but it is faster to do the
+# compiling and linking in one step, so that's how it's done.
+
+# Yacc for C programs
+# `N.c' is made automatically from `N.y' by running Yacc with the
+# command `$(YACC) $(YFLAGS)'.
+
+%.c: %.y
+
+# Lex for C programs
+# `N.c' is made automatically from `N.l' by by running Lex. The
+# actual command is `$(LEX) $(LFLAGS)'.
+
+%.c: %.l
+
+# Lex for Ratfor programs
+# `N.r' is made automatically from `N.l' by by running Lex. The
+# actual command is `$(LEX) $(LFLAGS)'.
+
+%.r: %.l
+
+# The convention of using the same suffix `.l' for all Lex files
+# regardless of whether they produce C code or Ratfor code makes it
+# impossible for `make' to determine automatically which of the two
+# languages you are using in any particular case. If `make' is
+# called upon to remake an object file from a `.l' file, it must
+# guess which compiler to use. It will guess the C compiler, because
+# that is more common. If you are using Ratfor, make sure `make'
+# knows this by mentioning `N.r' in the makefile. Or, if you are
+# using Ratfor exclusively, with no C files, remove `.c' from the
+# list of implicit rule suffixes with:
+
+# .SUFFIXES:
+# .SUFFIXES: .o .r .f .l ...
+
+# Making Lint Libraries from C, Yacc, or Lex programs
+# `N.ln' is made from `N.c' by running `lint'. The precise command
+# is `$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i'. The same command is
+# used on the C code produced from `N.y' or `N.l'.
+
+%.ln: %.c
+
+# TeX and Web
+# `N.dvi' is made from `N.tex' with the command `$(TEX)'. `N.tex'
+# is made from `N.web' with `$(WEAVE)', or from `N.w' (and from
+# `N.ch' if it exists or can be made) with `$(CWEAVE)'. `N.p' is
+# made from `N.web' with `$(TANGLE)' and `N.c' is made from `N.w'
+# (and from `N.ch' if it exists or can be made) with `$(CTANGLE)'.
+
+%.dvi: %.tex
+%.tex: %.web
+%.tex: %.w
+%.tex: %.ch
+%.p: %.web
+%.c: %.w
+%.w: %.ch
+
+# Texinfo and Info
+# `N.dvi' is made from `N.texinfo', `N.texi', or `N.txinfo', with
+# the command `$(TEXI2DVI) $(TEXI2DVI_FLAGS)'. `N.info' is made from
+# `N.texinfo', `N.texi', or `N.txinfo', with the command
+# `$(MAKEINFO) $(MAKEINFO_FLAGS)'.
+
+%.dvi: %.texinfo
+%.dvi: %.texi
+%.dvi: %.txinfo
+
+%.info: %.texinfo
+%.info: %.texi
+%.info: %.txinfo
+
+# RCS
+# Any file `N' is extracted if necessary from an RCS file named
+# either `N,v' or `RCS/N,v'. The precise command used is
+# `$(CO) $(COFLAGS)'. `N' will not be extracted from RCS if it
+# already exists, even if the RCS file is newer. The rules for RCS
+# are terminal (*note Match-Anything Pattern Rules: Match-Anything
+# Rules.), so RCS files cannot be generated from another source;
+# they must actually exist.
+
+%: %,v
+%: RCS/%,v
+
+# SCCS
+# Any file `N' is extracted if necessary from an SCCS file named
+# either `s.N' or `SCCS/s.N'. The precise command used is
+# `$(GET) $(GFLAGS)'. The rules for SCCS are terminal (*note
+# Match-Anything Pattern Rules: Match-Anything Rules.), so SCCS
+# files cannot be generated from another source; they must actually
+# exist.
+
+%: s.%
+%: SCCS/s.%
+
+# For the benefit of SCCS, a file `N' is copied from `N.sh' and made
+# executable (by everyone). This is for shell scripts that are
+# checked into SCCS. Since RCS preserves the execution permission
+# of a file, you do not need to use this feature with RCS.
+
+%: %.sh
+
+# We recommend that you avoid using of SCCS. RCS is widely held to
+# be superior, and is also free. By choosing free software in place
+# of comparable (or inferior) proprietary software, you support the
+# free software movement.
+
+# Usually, you want to change only the variables listed in the table
+# above, which are documented in the following section.
+
+# However, the commands in built-in implicit rules actually use
+# variables such as `COMPILE.c', `LINK.p', and `PREPROCESS.S', whose
+# values contain the commands listed above.
+
+# `make' follows the convention that the rule to compile a `.X' source
+# file uses the variable `COMPILE.X'. Similarly, the rule to produce an
+# executable from a `.X' file uses `LINK.X'; and the rule to preprocess a
+# `.X' file uses `PREPROCESS.X'.
+
+# Every rule that produces an object file uses the variable
+# `OUTPUT_OPTION'. `make' defines this variable either to contain `-o
+# $@', or to be empty, depending on a compile-time option. You need the
+# `-o' option to ensure that the output goes into the right file when the
+# source file is in a different directory, as when using `VPATH' (*note
+# Directory Search::). However, compilers on some systems do not accept
+# a `-o' switch for object files. If you use such a system, and use
+# `VPATH', some compilations will put their output in the wrong place. A
+# possible workaround for this problem is to give `OUTPUT_OPTION' the
+# value `; mv $*.o $@'.
+
+
projects / lilypond.git / commitdiff