Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(3473)

Side by Side Diff: stepmake/stepmake/no-builtin-rules.make

Issue 577280043: Cleanup unneeded parts of Stepmake (Closed)
Patch Set: Created 4 years, 2 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « stepmake/stepmake/makedir-vars.make ('k') | stepmake/stepmake/shared-library-rules.make » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 # UGH. GNU make comes with implicit rules.
2 # We don't want any of them, and can't force users to run
3 # --no-builtin-rules
4
5 .SUFFIXES:
6
7 #Compiling C programs
8 # `N.o' is made automatically from `N.c' with a command of the form
9 # `$(CC) -c $(CPPFLAGS) $(CFLAGS)'.
10
11 %.o: %.c
12
13 # Compiling C++ programs
14 # `N.o' is made automatically from `N.cc' or `N.C' with a command of
15 # the form `$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)'. We encourage you to
16 # use the suffix `.cc' for C++ source files instead of `.C'.
17
18 %.o: %.cc
19
20 # Compiling Pascal programs
21 # `N.o' is made automatically from `N.p' with the command `$(PC) -c
22 # $(PFLAGS)'.
23
24 %.o: %.p
25
26 # Compiling Fortran and Ratfor programs
27 # `N.o' is made automatically from `N.r', `N.F' or `N.f' by running
28 # the Fortran compiler. The precise command used is as follows:
29
30 # `.f'
31 # `$(FC) -c $(FFLAGS)'.
32
33 %.o: %.f
34
35 # `.F'
36 # `$(FC) -c $(FFLAGS) $(CPPFLAGS)'.
37
38 %.o: %.F
39
40 # `.r'
41 # `$(FC) -c $(FFLAGS) $(RFLAGS)'.
42
43 %.o: %.r
44
45 # Preprocessing Fortran and Ratfor programs
46 # `N.f' is made automatically from `N.r' or `N.F'. This rule runs
47 # just the preprocessor to convert a Ratfor or preprocessable
48 # Fortran program into a strict Fortran program. The precise
49 # command used is as follows:
50
51 # `.F'
52 # `$(FC) -F $(CPPFLAGS) $(FFLAGS)'.
53
54 %.f: %.F
55
56 # `.r'
57 # `$(FC) -F $(FFLAGS) $(RFLAGS)'.
58
59 %.f: %.r
60
61 # Compiling Modula-2 programs
62 # `N.sym' is made from `N.def' with a command of the form `$(M2C)
63 # $(M2FLAGS) $(DEFFLAGS)'. `N.o' is made from `N.mod'; the form is:
64 # `$(M2C) $(M2FLAGS) $(MODFLAGS)'.
65
66 %.sym: %.def
67 %.o: %.mod
68
69 # Assembling and preprocessing assembler programs
70 # `N.o' is made automatically from `N.s' by running the assembler,
71 # `as'. The precise command is `$(AS) $(ASFLAGS)'.
72
73 %.o: %.s
74
75 # `N.s' is made automatically from `N.S' by running the C
76 # preprocessor, `cpp'. The precise command is `$(CPP) $(CPPFLAGS)'.
77
78 %.s: %.S
79
80 # Linking a single object file
81 # `N' is made automatically from `N.o' by running the linker
82 # (usually called `ld') via the C compiler. The precise command
83 # used is `$(CC) $(LDFLAGS) N.o $(LOADLIBES) $(LDLIBS)'.
84
85 %: %.o
86
87 # This rule does the right thing for a simple program with only one
88 # source file. It will also do the right thing if there are multiple
89 # object files (presumably coming from various other source files),
90 # one of which has a name matching that of the executable file.
91 # Thus,
92
93 # x: y.o z.o
94
95 # when `x.c', `y.c' and `z.c' all exist will execute:
96
97 # cc -c x.c -o x.o
98 # cc -c y.c -o y.o
99 # cc -c z.c -o z.o
100 # cc x.o y.o z.o -o x
101 # rm -f x.o
102 # rm -f y.o
103 # rm -f z.o
104
105 # In more complicated cases, such as when there is no object file
106 # whose name derives from the executable file name, you must write
107 # an explicit command for linking.
108
109 # Each kind of file automatically made into `.o' object files will
110 # be automatically linked by using the compiler (`$(CC)', `$(FC)' or
111 # `$(PC)'; the C compiler `$(CC)' is used to assemble `.s' files)
112 # without the `-c' option. This could be done by using the `.o'
113 # object files as intermediates, but it is faster to do the
114 # compiling and linking in one step, so that's how it's done.
115
116 # Yacc for C programs
117 # `N.c' is made automatically from `N.y' by running Yacc with the
118 # command `$(YACC) $(YFLAGS)'.
119
120 %.c: %.y
121
122 # Lex for C programs
123 # `N.c' is made automatically from `N.l' by by running Lex. The
124 # actual command is `$(LEX) $(LFLAGS)'.
125
126 %.c: %.l
127
128 # Lex for Ratfor programs
129 # `N.r' is made automatically from `N.l' by by running Lex. The
130 # actual command is `$(LEX) $(LFLAGS)'.
131
132 %.r: %.l
133
134 # The convention of using the same suffix `.l' for all Lex files
135 # regardless of whether they produce C code or Ratfor code makes it
136 # impossible for `make' to determine automatically which of the two
137 # languages you are using in any particular case. If `make' is
138 # called upon to remake an object file from a `.l' file, it must
139 # guess which compiler to use. It will guess the C compiler, because
140 # that is more common. If you are using Ratfor, make sure `make'
141 # knows this by mentioning `N.r' in the makefile. Or, if you are
142 # using Ratfor exclusively, with no C files, remove `.c' from the
143 # list of implicit rule suffixes with:
144
145 # .SUFFIXES:
146 # .SUFFIXES: .o .r .f .l ...
147
148 # Making Lint Libraries from C, Yacc, or Lex programs
149 # `N.ln' is made from `N.c' by running `lint'. The precise command
150 # is `$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i'. The same command is
151 # used on the C code produced from `N.y' or `N.l'.
152
153 %.ln: %.c
154
155 # TeX and Web
156 # `N.dvi' is made from `N.tex' with the command `$(TEX)'. `N.tex'
157 # is made from `N.web' with `$(WEAVE)', or from `N.w' (and from
158 # `N.ch' if it exists or can be made) with `$(CWEAVE)'. `N.p' is
159 # made from `N.web' with `$(TANGLE)' and `N.c' is made from `N.w'
160 # (and from `N.ch' if it exists or can be made) with `$(CTANGLE)'.
161
162 %.dvi: %.tex
163 %.tex: %.web
164 %.tex: %.w
165 %.tex: %.ch
166 %.p: %.web
167 %.c: %.w
168 %.w: %.ch
169
170 # Texinfo and Info
171 # `N.dvi' is made from `N.texinfo', `N.texi', or `N.txinfo', with
172 # the command `$(TEXI2DVI) $(TEXI2DVI_FLAGS)'. `N.info' is made from
173 # `N.texinfo', `N.texi', or `N.txinfo', with the command
174 # `$(MAKEINFO) $(MAKEINFO_FLAGS)'.
175
176 %.dvi: %.texinfo
177 %.dvi: %.texi
178 %.dvi: %.txinfo
179
180 %.info: %.texinfo
181 %.info: %.texi
182 %.info: %.txinfo
183
184 # RCS
185 # Any file `N' is extracted if necessary from an RCS file named
186 # either `N,v' or `RCS/N,v'. The precise command used is
187 # `$(CO) $(COFLAGS)'. `N' will not be extracted from RCS if it
188 # already exists, even if the RCS file is newer. The rules for RCS
189 # are terminal (*note Match-Anything Pattern Rules: Match-Anything
190 # Rules.), so RCS files cannot be generated from another source;
191 # they must actually exist.
192
193 %: %,v
194 %: RCS/%,v
195
196 # SCCS
197 # Any file `N' is extracted if necessary from an SCCS file named
198 # either `s.N' or `SCCS/s.N'. The precise command used is
199 # `$(GET) $(GFLAGS)'. The rules for SCCS are terminal (*note
200 # Match-Anything Pattern Rules: Match-Anything Rules.), so SCCS
201 # files cannot be generated from another source; they must actually
202 # exist.
203
204 %: s.%
205 %: SCCS/s.%
206
207 # For the benefit of SCCS, a file `N' is copied from `N.sh' and made
208 # executable (by everyone). This is for shell scripts that are
209 # checked into SCCS. Since RCS preserves the execution permission
210 # of a file, you do not need to use this feature with RCS.
211
212 %: %.sh
213
214 # We recommend that you avoid using of SCCS. RCS is widely held to
215 # be superior, and is also free. By choosing free software in place
216 # of comparable (or inferior) proprietary software, you support the
217 # free software movement.
218
219 # Usually, you want to change only the variables listed in the table
220 # above, which are documented in the following section.
221
222 # However, the commands in built-in implicit rules actually use
223 # variables such as `COMPILE.c', `LINK.p', and `PREPROCESS.S', whose
224 # values contain the commands listed above.
225
226 # `make' follows the convention that the rule to compile a `.X' source
227 # file uses the variable `COMPILE.X'. Similarly, the rule to produce an
228 # executable from a `.X' file uses `LINK.X'; and the rule to preprocess a
229 # `.X' file uses `PREPROCESS.X'.
230
231 # Every rule that produces an object file uses the variable
232 # `OUTPUT_OPTION'. `make' defines this variable either to contain `-o
233 # $@', or to be empty, depending on a compile-time option. You need the
234 # `-o' option to ensure that the output goes into the right file when the
235 # source file is in a different directory, as when using `VPATH' (*note
236 # Directory Search::). However, compilers on some systems do not accept
237 # a `-o' switch for object files. If you use such a system, and use
238 # `VPATH', some compilations will put their output in the wrong place. A
239 # possible workaround for this problem is to give `OUTPUT_OPTION' the
240 # value `; mv $*.o $@'.
241
242
OLDNEW
« no previous file with comments | « stepmake/stepmake/makedir-vars.make ('k') | stepmake/stepmake/shared-library-rules.make » ('j') | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b