]>
Commit | Line | Data |
---|---|---|
49e6c08e | 1 | /* Dependency generator for Makefile fragments. |
0c20a65f | 2 | Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc. |
49e6c08e ZW |
3 | Contributed by Zack Weinberg, Mar 2000 |
4 | ||
5 | This program is free software; you can redistribute it and/or modify it | |
6 | under the terms of the GNU General Public License as published by the | |
7 | Free Software Foundation; either version 2, or (at your option) any | |
8 | later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 | ||
19 | In other words, you are welcome to use, share and improve this program. | |
20 | You are forbidden to forbid anyone else to use, share and improve | |
21 | what you give them. Help stamp out software-hoarding! */ | |
22 | ||
23 | #include "config.h" | |
24 | #include "system.h" | |
25 | #include "mkdeps.h" | |
26 | ||
03b9ab42 NB |
27 | /* Keep this structure local to this file, so clients don't find it |
28 | easy to start making assumptions. */ | |
29 | struct deps | |
30 | { | |
31 | const char **targetv; | |
32 | unsigned int ntargets; /* number of slots actually occupied */ | |
33 | unsigned int targets_size; /* amt of allocated space - in words */ | |
34 | ||
35 | const char **depv; | |
36 | unsigned int ndeps; | |
37 | unsigned int deps_size; | |
38 | }; | |
39 | ||
0c20a65f | 40 | static const char *munge (const char *); |
49e6c08e | 41 | |
49e6c08e ZW |
42 | /* Given a filename, quote characters in that filename which are |
43 | significant to Make. Note that it's not possible to quote all such | |
44 | characters - e.g. \n, %, *, ?, [, \ (in some contexts), and ~ are | |
45 | not properly handled. It isn't possible to get this right in any | |
46 | current version of Make. (??? Still true? Old comment referred to | |
47 | 3.76.1.) */ | |
0c20a65f | 48 | |
49e6c08e | 49 | static const char * |
0c20a65f | 50 | munge (const char *filename) |
49e6c08e ZW |
51 | { |
52 | int len; | |
53 | const char *p, *q; | |
54 | char *dst, *buffer; | |
55 | ||
56 | for (p = filename, len = 0; *p; p++, len++) | |
57 | { | |
58 | switch (*p) | |
59 | { | |
60 | case ' ': | |
61 | case '\t': | |
62 | /* GNU make uses a weird quoting scheme for white space. | |
63 | A space or tab preceded by 2N+1 backslashes represents | |
64 | N backslashes followed by space; a space or tab | |
65 | preceded by 2N backslashes represents N backslashes at | |
66 | the end of a file name; and backslashes in other | |
67 | contexts should not be doubled. */ | |
e23c0ba3 | 68 | for (q = p - 1; filename <= q && *q == '\\'; q--) |
49e6c08e ZW |
69 | len++; |
70 | len++; | |
71 | break; | |
72 | ||
73 | case '$': | |
a5a4ce3c | 74 | /* '$' is quoted by doubling it. */ |
49e6c08e ZW |
75 | len++; |
76 | break; | |
77 | } | |
78 | } | |
79 | ||
80 | /* Now we know how big to make the buffer. */ | |
dd3b81b4 | 81 | buffer = xmalloc (len + 1); |
49e6c08e ZW |
82 | |
83 | for (p = filename, dst = buffer; *p; p++, dst++) | |
84 | { | |
85 | switch (*p) | |
86 | { | |
87 | case ' ': | |
88 | case '\t': | |
e23c0ba3 | 89 | for (q = p - 1; filename <= q && *q == '\\'; q--) |
49e6c08e ZW |
90 | *dst++ = '\\'; |
91 | *dst++ = '\\'; | |
92 | break; | |
93 | ||
94 | case '$': | |
95 | *dst++ = '$'; | |
96 | break; | |
97 | ||
98 | default: | |
99 | /* nothing */; | |
100 | } | |
101 | *dst = *p; | |
102 | } | |
103 | ||
104 | *dst = '\0'; | |
105 | return buffer; | |
106 | } | |
107 | ||
49e6c08e ZW |
108 | /* Public routines. */ |
109 | ||
110 | struct deps * | |
0c20a65f | 111 | deps_init (void) |
49e6c08e ZW |
112 | { |
113 | struct deps *d = (struct deps *) xmalloc (sizeof (struct deps)); | |
114 | ||
f7114e17 | 115 | /* Allocate space for the vectors only if we need it. */ |
49e6c08e | 116 | |
f7114e17 NB |
117 | d->targetv = 0; |
118 | d->depv = 0; | |
49e6c08e ZW |
119 | |
120 | d->ntargets = 0; | |
f7114e17 | 121 | d->targets_size = 0; |
49e6c08e | 122 | d->ndeps = 0; |
f7114e17 | 123 | d->deps_size = 0; |
49e6c08e ZW |
124 | |
125 | return d; | |
126 | } | |
127 | ||
128 | void | |
0c20a65f | 129 | deps_free (struct deps *d) |
49e6c08e ZW |
130 | { |
131 | unsigned int i; | |
05bccae2 | 132 | |
f7114e17 NB |
133 | if (d->targetv) |
134 | { | |
135 | for (i = 0; i < d->ntargets; i++) | |
fad205ff | 136 | free ((void *) d->targetv[i]); |
f7114e17 NB |
137 | free (d->targetv); |
138 | } | |
05bccae2 | 139 | |
f7114e17 NB |
140 | if (d->depv) |
141 | { | |
142 | for (i = 0; i < d->ndeps; i++) | |
fad205ff | 143 | free ((void *) d->depv[i]); |
f7114e17 NB |
144 | free (d->depv); |
145 | } | |
49e6c08e | 146 | |
49e6c08e ZW |
147 | free (d); |
148 | } | |
149 | ||
a5a4ce3c NB |
150 | /* Adds a target T. We make a copy, so it need not be a permanent |
151 | string. QUOTE is true if the string should be quoted. */ | |
49e6c08e | 152 | void |
0c20a65f | 153 | deps_add_target (struct deps *d, const char *t, int quote) |
49e6c08e | 154 | { |
49e6c08e ZW |
155 | if (d->ntargets == d->targets_size) |
156 | { | |
f7114e17 | 157 | d->targets_size = d->targets_size * 2 + 4; |
7ceb3598 | 158 | d->targetv = (const char **) xrealloc (d->targetv, |
49e6c08e ZW |
159 | d->targets_size * sizeof (const char *)); |
160 | } | |
05bccae2 | 161 | |
a5a4ce3c NB |
162 | if (quote) |
163 | t = munge (t); /* Also makes permanent copy. */ | |
164 | else | |
165 | t = xstrdup (t); | |
166 | ||
49e6c08e ZW |
167 | d->targetv[d->ntargets++] = t; |
168 | } | |
169 | ||
03b9ab42 | 170 | /* Sets the default target if none has been given already. An empty |
a5a4ce3c NB |
171 | string as the default target in interpreted as stdin. The string |
172 | is quoted for MAKE. */ | |
49e6c08e | 173 | void |
0c20a65f | 174 | deps_add_default_target (struct deps *d, const char *tgt) |
49e6c08e | 175 | { |
03b9ab42 NB |
176 | /* Only if we have no targets. */ |
177 | if (d->ntargets) | |
178 | return; | |
49e6c08e | 179 | |
03b9ab42 | 180 | if (tgt[0] == '\0') |
a5a4ce3c | 181 | deps_add_target (d, "-", 1); |
49e6c08e | 182 | else |
03b9ab42 | 183 | { |
45936a85 DD |
184 | #ifndef TARGET_OBJECT_SUFFIX |
185 | # define TARGET_OBJECT_SUFFIX ".o" | |
03b9ab42 | 186 | #endif |
0821bff7 | 187 | const char *start = lbasename (tgt); |
45936a85 | 188 | char *o = (char *) alloca (strlen (start) + strlen (TARGET_OBJECT_SUFFIX) + 1); |
48ce6bbb | 189 | char *suffix; |
03b9ab42 | 190 | |
48ce6bbb | 191 | strcpy (o, start); |
0c20a65f | 192 | |
48ce6bbb NS |
193 | suffix = strrchr (o, '.'); |
194 | if (!suffix) | |
195 | suffix = o + strlen (o); | |
45936a85 | 196 | strcpy (suffix, TARGET_OBJECT_SUFFIX); |
0c20a65f | 197 | |
a5a4ce3c | 198 | deps_add_target (d, o, 1); |
03b9ab42 | 199 | } |
49e6c08e ZW |
200 | } |
201 | ||
202 | void | |
0c20a65f | 203 | deps_add_dep (struct deps *d, const char *t) |
49e6c08e ZW |
204 | { |
205 | t = munge (t); /* Also makes permanent copy. */ | |
206 | ||
207 | if (d->ndeps == d->deps_size) | |
208 | { | |
fa6f74f6 | 209 | d->deps_size = d->deps_size * 2 + 8; |
7ceb3598 NB |
210 | d->depv = (const char **) |
211 | xrealloc (d->depv, d->deps_size * sizeof (const char *)); | |
49e6c08e ZW |
212 | } |
213 | d->depv[d->ndeps++] = t; | |
214 | } | |
215 | ||
216 | void | |
0c20a65f | 217 | deps_write (const struct deps *d, FILE *fp, unsigned int colmax) |
49e6c08e ZW |
218 | { |
219 | unsigned int size, i, column; | |
220 | ||
221 | column = 0; | |
222 | if (colmax && colmax < 34) | |
223 | colmax = 34; | |
224 | ||
225 | for (i = 0; i < d->ntargets; i++) | |
226 | { | |
227 | size = strlen (d->targetv[i]); | |
228 | column += size; | |
229 | if (colmax && column > colmax) | |
230 | { | |
231 | fputs (" \\\n ", fp); | |
232 | column = 1 + size; | |
233 | } | |
234 | if (i) | |
235 | { | |
236 | putc (' ', fp); | |
237 | column++; | |
238 | } | |
239 | fputs (d->targetv[i], fp); | |
240 | } | |
241 | ||
242 | putc (':', fp); | |
243 | putc (' ', fp); | |
244 | column += 2; | |
245 | ||
246 | for (i = 0; i < d->ndeps; i++) | |
247 | { | |
248 | size = strlen (d->depv[i]); | |
249 | column += size; | |
250 | if (colmax && column > colmax) | |
251 | { | |
252 | fputs (" \\\n ", fp); | |
253 | column = 1 + size; | |
254 | } | |
255 | if (i) | |
256 | { | |
257 | putc (' ', fp); | |
258 | column++; | |
259 | } | |
260 | fputs (d->depv[i], fp); | |
261 | } | |
262 | putc ('\n', fp); | |
263 | } | |
0c20a65f | 264 | |
49e6c08e | 265 | void |
0c20a65f | 266 | deps_phony_targets (const struct deps *d, FILE *fp) |
49e6c08e | 267 | { |
05bccae2 | 268 | unsigned int i; |
49e6c08e ZW |
269 | |
270 | for (i = 1; i < d->ndeps; i++) | |
271 | { | |
a5a4ce3c | 272 | putc ('\n', fp); |
49e6c08e ZW |
273 | fputs (d->depv[i], fp); |
274 | putc (':', fp); | |
275 | putc ('\n', fp); | |
276 | } | |
277 | } | |
17211ab5 GK |
278 | |
279 | /* Write out a deps buffer to a file, in a form that can be read back | |
280 | with deps_restore. Returns nonzero on error, in which case the | |
281 | error number will be in errno. */ | |
282 | ||
283 | int | |
0c20a65f | 284 | deps_save (struct deps *deps, FILE *f) |
17211ab5 GK |
285 | { |
286 | unsigned int i; | |
287 | ||
288 | /* The cppreader structure contains makefile dependences. Write out this | |
289 | structure. */ | |
290 | ||
291 | /* The number of dependences. */ | |
292 | if (fwrite (&deps->ndeps, sizeof (deps->ndeps), 1, f) != 1) | |
293 | return -1; | |
294 | /* The length of each dependence followed by the string. */ | |
295 | for (i = 0; i < deps->ndeps; i++) | |
296 | { | |
297 | size_t num_to_write = strlen (deps->depv[i]); | |
298 | if (fwrite (&num_to_write, sizeof (size_t), 1, f) != 1) | |
299 | return -1; | |
300 | if (fwrite (deps->depv[i], num_to_write, 1, f) != 1) | |
301 | return -1; | |
302 | } | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | /* Read back dependency information written with deps_save into | |
308 | the deps buffer. The third argument may be NULL, in which case | |
309 | the dependency information is just skipped, or it may be a filename, | |
310 | in which case that filename is skipped. */ | |
311 | ||
312 | int | |
0c20a65f | 313 | deps_restore (struct deps *deps, FILE *fd, const char *self) |
17211ab5 GK |
314 | { |
315 | unsigned int i, count; | |
316 | size_t num_to_read; | |
317 | size_t buf_size = 512; | |
318 | char *buf = (char *) xmalloc (buf_size); | |
319 | ||
320 | /* Number of dependences. */ | |
321 | if (fread (&count, 1, sizeof (count), fd) != sizeof (count)) | |
322 | return -1; | |
323 | ||
324 | /* The length of each dependence string, followed by the string. */ | |
325 | for (i = 0; i < count; i++) | |
326 | { | |
327 | /* Read in # bytes in string. */ | |
328 | if (fread (&num_to_read, 1, sizeof (size_t), fd) != sizeof (size_t)) | |
329 | return -1; | |
330 | if (buf_size < num_to_read + 1) | |
331 | { | |
332 | buf_size = num_to_read + 1 + 127; | |
333 | buf = xrealloc (buf, buf_size); | |
334 | } | |
335 | if (fread (buf, 1, num_to_read, fd) != num_to_read) | |
336 | return -1; | |
337 | buf[num_to_read] = '\0'; | |
338 | ||
0c20a65f | 339 | /* Generate makefile dependencies from .pch if -nopch-deps. */ |
17211ab5 GK |
340 | if (self != NULL && strcmp (buf, self) != 0) |
341 | deps_add_dep (deps, buf); | |
342 | } | |
343 | ||
344 | free (buf); | |
345 | return 0; | |
346 | } |