Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /* $XConsortium: main.c,v 1.84 94/11/30 16:10:44 kaleb Exp $ */
3 : /* $XFree86: xc/config/makedepend/main.c,v 3.4 1995/07/15 14:53:49 dawes Exp $ */
4 : /*
5 :
6 : Copyright (c) 1993, 1994 X Consortium
7 :
8 : Permission is hereby granted, free of charge, to any person obtaining a copy
9 : of this software and associated documentation files (the "Software"), to deal
10 : in the Software without restriction, including without limitation the rights
11 : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 : copies of the Software, and to permit persons to whom the Software is
13 : furnished to do so, subject to the following conditions:
14 :
15 : The above copyright notice and this permission notice shall be included in
16 : all copies or substantial portions of the Software.
17 :
18 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 : X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 : AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 : CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 :
25 : Except as contained in this notice, the name of the X Consortium shall not be
26 : used in advertising or otherwise to promote the sale, use or other dealings
27 : in this Software without prior written authorization from the X Consortium.
28 :
29 : */
30 :
31 : #if defined(FREEBSD) || defined(MACOSX)
32 : #include <sys/types.h>
33 : #include <sys/stat.h>
34 : #endif
35 :
36 : #ifdef _WIN32
37 : #include <io.h>
38 : #endif
39 :
40 : #ifdef _MSC_VER /* Define ssize_t */
41 :
42 : #if !defined(_W64)
43 : #if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
44 : #define _W64 __w64
45 : #else
46 : #define _W64
47 : #endif
48 : #endif
49 :
50 : #ifdef _WIN64
51 : typedef __int64 ssize_t;
52 : #else
53 : typedef _W64 int ssize_t;
54 : #endif
55 :
56 : #endif
57 :
58 : #include "def.h"
59 : #include <string.h>
60 : #ifdef hpux
61 : #define sigvec sigvector
62 : #endif /* hpux */
63 :
64 : #ifdef X_POSIX_C_SOURCE
65 : #define _POSIX_C_SOURCE X_POSIX_C_SOURCE
66 : #include <signal.h>
67 : #undef _POSIX_C_SOURCE
68 : #else
69 : #if defined(X_NOT_POSIX) || defined(_POSIX_SOURCE)
70 : #include <signal.h>
71 : #else
72 : #define _POSIX_SOURCE
73 : #include <signal.h>
74 : #undef _POSIX_SOURCE
75 : #endif
76 : #endif
77 :
78 : #include <stdarg.h>
79 :
80 : #ifdef MINIX
81 : #define USE_CHMOD 1
82 : #endif
83 :
84 : #ifdef DEBUG
85 : int _debugmask;
86 : #endif
87 :
88 : char *ProgramName;
89 :
90 : #define OBJSUFFIX ".obj"
91 : #define INCLUDEDIR "."
92 :
93 : char *directives[] = {
94 : "if",
95 : "ifdef",
96 : "ifndef",
97 : "else",
98 : "endif",
99 : "define",
100 : "undef",
101 : "include",
102 : "line",
103 : "pragma",
104 : "error",
105 : "ident",
106 : "sccs",
107 : "elif",
108 : "eject",
109 : NULL
110 : };
111 :
112 : #define MAKEDEPEND
113 : #include "imakemdep.h" /* from config sources */
114 : #undef MAKEDEPEND
115 :
116 : /******* function declarations ********/
117 : /******* added by -Wall project *******/
118 : void redirect(char * line, char * makefile );
119 :
120 : struct inclist inclist[ MAXFILES ],
121 : *inclistp = inclist;
122 :
123 : struct symhash *maininclist = NULL;
124 :
125 : char *filelist[ MAXFILES ];
126 : char *includedirs[ MAXDIRS + 1 ];
127 : char *notdotdot[ MAXDIRS ];
128 : char *objprefix = "";
129 : char *objsuffix = OBJSUFFIX;
130 : char *startat = "# DO NOT DELETE";
131 : int width = 78;
132 : boolean append = FALSE;
133 : boolean printed = FALSE;
134 : boolean verbose = FALSE;
135 : boolean show_where_not = FALSE;
136 : boolean warn_multiple = FALSE; /* Warn on multiple includes of same file */
137 :
138 : static
139 : #ifdef SIGNALRETURNSINT
140 : int
141 : #else
142 : void
143 : #endif
144 0 : catch (int sig)
145 : {
146 0 : fflush (stdout);
147 0 : fatalerr ("got signal %d\n", sig);
148 0 : }
149 :
150 : #if (defined(i386) && defined(SYSV)) || defined(WIN32)
151 : #define USGISH
152 : #endif
153 :
154 : #ifndef USGISH
155 : #ifndef _POSIX_SOURCE
156 : #define sigaction sigvec
157 : #define sa_handler sv_handler
158 : #define sa_mask sv_mask
159 : #define sa_flags sv_flags
160 : #endif
161 : struct sigaction sig_act;
162 : #endif /* USGISH */
163 :
164 : boolean native_win_slashes = FALSE;
165 :
166 2 : int main(argc, argv)
167 : int argc;
168 : char **argv;
169 : {
170 2 : register char **fp = filelist;
171 2 : register char **incp = includedirs;
172 : register char *p;
173 : register struct inclist *ip;
174 2 : char *makefile = NULL;
175 : struct filepointer *filecontent;
176 2 : struct pair *psymp = predefs;
177 2 : char *endmarker = NULL;
178 2 : char *defincdir = NULL;
179 : struct IncludesCollection* incCollection;
180 :
181 2 : ProgramName = argv[0];
182 :
183 8 : while (psymp->p_name)
184 : {
185 4 : hash_define(psymp->p_name, psymp->p_value, &maininclist);
186 4 : psymp++;
187 : }
188 2 : if (argc == 2 && argv[1][0] == '@') {
189 : struct stat ast;
190 : int afd;
191 : char *args;
192 : char **nargv;
193 : int nargc;
194 2 : char quotechar = '\0';
195 :
196 2 : nargc = 1;
197 2 : if ((afd = open(argv[1]+1, O_RDONLY)) < 0)
198 0 : fatalerr("cannot open \"%s\"\n", argv[1]+1);
199 2 : fstat(afd, &ast);
200 2 : args = (char *)malloc(ast.st_size + 1);
201 2 : if ((ast.st_size = read(afd, args, (size_t) ast.st_size)) < 0)
202 0 : fatalerr("failed to read %s\n", argv[1]+1);
203 2 : args[ast.st_size] = '\0';
204 2 : close(afd);
205 939 : for (p = args; *p; p++) {
206 937 : if (quotechar) {
207 0 : if (quotechar == '\\'
208 0 : || (*p == quotechar && p[-1] != '\\'))
209 0 : quotechar = '\0';
210 0 : continue;
211 : }
212 937 : switch (*p) {
213 : case '\\':
214 : case '"':
215 : case '\'':
216 0 : quotechar = *p;
217 0 : break;
218 : case ' ':
219 : case '\n':
220 75 : *p = '\0';
221 75 : if (p > args && p[-1])
222 66 : nargc++;
223 75 : break;
224 : }
225 : }
226 2 : if (p[-1])
227 0 : nargc++;
228 2 : nargv = (char **)malloc(nargc * sizeof(char *));
229 2 : nargv[0] = argv[0];
230 2 : argc = 1;
231 77 : for (p = args; argc < nargc; p += strlen(p) + 1)
232 75 : if (*p) nargv[argc++] = p;
233 2 : argv = nargv;
234 : }
235 66 : for(argc--, argv++; argc; argc--, argv++) {
236 : /* if looking for endmarker then check before parsing */
237 64 : if (endmarker && strcmp (endmarker, *argv) == 0) {
238 0 : endmarker = NULL;
239 0 : continue;
240 : }
241 64 : if (**argv != '-') {
242 : /* treat +thing as an option for C++ */
243 2 : if (endmarker && **argv == '+')
244 0 : continue;
245 2 : *fp++ = argv[0];
246 2 : continue;
247 : }
248 62 : switch(argv[0][1]) {
249 : case '-':
250 0 : endmarker = &argv[0][2];
251 0 : if (endmarker[0] == '\0') endmarker = "--";
252 0 : break;
253 : case 'D':
254 44 : if (argv[0][2] == '\0') {
255 0 : argv++;
256 0 : argc--;
257 : }
258 432 : for (p=argv[0] + 2; *p ; p++)
259 398 : if (*p == '=') {
260 10 : *p = ' ';
261 10 : break;
262 : }
263 44 : define(argv[0] + 2, &maininclist);
264 44 : break;
265 : case 'I':
266 14 : if (incp >= includedirs + MAXDIRS)
267 0 : fatalerr("Too many -I flags.\n");
268 14 : *incp++ = argv[0]+2;
269 14 : if (**(incp-1) == '\0') {
270 0 : *(incp-1) = *(++argv);
271 0 : argc--;
272 : }
273 14 : break;
274 : case 'Y':
275 0 : defincdir = argv[0]+2;
276 0 : break;
277 : /* do not use if endmarker processing */
278 : case 'a':
279 0 : if (endmarker) break;
280 0 : append = TRUE;
281 0 : break;
282 : case 'w':
283 0 : if (endmarker) break;
284 0 : if (argv[0][2] == '\0') {
285 0 : argv++;
286 0 : argc--;
287 0 : width = atoi(argv[0]);
288 : } else
289 0 : width = atoi(argv[0]+2);
290 0 : break;
291 : case 'n':
292 : // Use "-n" switch to generate dependencies with windows-native slash style
293 0 : native_win_slashes = TRUE;
294 0 : break;
295 : case 'o':
296 0 : if (endmarker) break;
297 0 : if (argv[0][2] == '\0') {
298 0 : argv++;
299 0 : argc--;
300 0 : objsuffix = argv[0];
301 : } else
302 0 : objsuffix = argv[0]+2;
303 0 : break;
304 : case 'p':
305 2 : if (endmarker) break;
306 2 : if (argv[0][2] == '\0') {
307 0 : argv++;
308 0 : argc--;
309 0 : objprefix = argv[0];
310 : } else
311 2 : objprefix = argv[0]+2;
312 2 : break;
313 : case 'v':
314 0 : if (endmarker) break;
315 0 : verbose = TRUE;
316 : #ifdef DEBUG
317 : if (argv[0][2])
318 : _debugmask = atoi(argv[0]+2);
319 : #endif
320 0 : break;
321 : case 's':
322 0 : if (endmarker) break;
323 0 : startat = argv[0]+2;
324 0 : if (*startat == '\0') {
325 0 : startat = *(++argv);
326 0 : argc--;
327 : }
328 0 : if (*startat != '#')
329 0 : fatalerr("-s flag's value should start %s\n",
330 : "with '#'.");
331 0 : break;
332 : case 'f':
333 2 : if (endmarker) break;
334 2 : makefile = argv[0]+2;
335 2 : if (*makefile == '\0') {
336 2 : makefile = *(++argv);
337 2 : argc--;
338 : }
339 2 : break;
340 :
341 : case 'm':
342 0 : warn_multiple = TRUE;
343 0 : break;
344 :
345 : /* Ignore -O, -g so we can just pass ${CFLAGS} to
346 : makedepend
347 : */
348 : case 'O':
349 : case 'g':
350 0 : break;
351 : default:
352 0 : if (endmarker) break;
353 0 : warning("ignoring option %s\n", argv[0]);
354 : }
355 : }
356 :
357 2 : convert_slashes(objprefix);
358 2 : objprefix = append_slash(objprefix);
359 :
360 2 : if (!defincdir) {
361 : #ifdef PREINCDIR
362 : if (incp >= includedirs + MAXDIRS)
363 : fatalerr("Too many -I flags.\n");
364 : *incp++ = PREINCDIR;
365 : #endif
366 2 : if (incp >= includedirs + MAXDIRS)
367 0 : fatalerr("Too many -I flags.\n");
368 2 : *incp++ = INCLUDEDIR;
369 : #ifdef POSTINCDIR
370 : if (incp >= includedirs + MAXDIRS)
371 : fatalerr("Too many -I flags.\n");
372 : *incp++ = POSTINCDIR;
373 : #endif
374 0 : } else if (*defincdir) {
375 0 : if (incp >= includedirs + MAXDIRS)
376 0 : fatalerr("Too many -I flags.\n");
377 0 : *incp++ = defincdir;
378 : }
379 :
380 2 : redirect(startat, makefile);
381 :
382 : /*
383 : * catch signals.
384 : */
385 : #ifdef USGISH
386 : /* should really reset SIGINT to SIG_IGN if it was. */
387 : #ifdef SIGHUP
388 : signal (SIGHUP, catch);
389 : #endif
390 : signal (SIGINT, catch);
391 : #ifdef SIGQUIT
392 : signal (SIGQUIT, catch);
393 : #endif
394 : signal (SIGILL, catch);
395 : #ifdef SIGBUS
396 : signal (SIGBUS, catch);
397 : #endif
398 : signal (SIGSEGV, catch);
399 : #ifdef SIGSYS
400 : signal (SIGSYS, catch);
401 : #endif
402 : signal (SIGFPE, catch);
403 : #else
404 2 : sig_act.sa_handler = catch;
405 : #ifdef _POSIX_SOURCE
406 2 : sigemptyset(&sig_act.sa_mask);
407 2 : sigaddset(&sig_act.sa_mask, SIGINT);
408 2 : sigaddset(&sig_act.sa_mask, SIGQUIT);
409 : #ifdef SIGBUS
410 2 : sigaddset(&sig_act.sa_mask, SIGBUS);
411 : #endif
412 2 : sigaddset(&sig_act.sa_mask, SIGILL);
413 2 : sigaddset(&sig_act.sa_mask, SIGSEGV);
414 2 : sigaddset(&sig_act.sa_mask, SIGHUP);
415 2 : sigaddset(&sig_act.sa_mask, SIGPIPE);
416 : #ifdef SIGSYS
417 2 : sigaddset(&sig_act.sa_mask, SIGSYS);
418 : #endif
419 : #else
420 : sig_act.sa_mask = ((1<<(SIGINT -1))
421 : |(1<<(SIGQUIT-1))
422 : #ifdef SIGBUS
423 : |(1<<(SIGBUS-1))
424 : #endif
425 : |(1<<(SIGILL-1))
426 : |(1<<(SIGSEGV-1))
427 : |(1<<(SIGHUP-1))
428 : |(1<<(SIGPIPE-1))
429 : #ifdef SIGSYS
430 : |(1<<(SIGSYS-1))
431 : #endif
432 : );
433 : #endif /* _POSIX_SOURCE */
434 2 : sig_act.sa_flags = 0;
435 2 : sigaction(SIGHUP, &sig_act, (struct sigaction *)0);
436 2 : sigaction(SIGINT, &sig_act, (struct sigaction *)0);
437 2 : sigaction(SIGQUIT, &sig_act, (struct sigaction *)0);
438 2 : sigaction(SIGILL, &sig_act, (struct sigaction *)0);
439 : #ifdef SIGBUS
440 2 : sigaction(SIGBUS, &sig_act, (struct sigaction *)0);
441 : #endif
442 2 : sigaction(SIGSEGV, &sig_act, (struct sigaction *)0);
443 : #ifdef SIGSYS
444 2 : sigaction(SIGSYS, &sig_act, (struct sigaction *)0);
445 : #endif
446 : #endif /* USGISH */
447 :
448 : /*
449 : * now peruse through the list of files.
450 : */
451 2 : incCollection = create_IncludesCollection();
452 :
453 4 : for(fp=filelist; *fp; fp++) {
454 : struct symhash *includes;
455 2 : filecontent = getfile(*fp);
456 2 : ip = newinclude(*fp, (char *)NULL);
457 :
458 2 : includes = hash_copy( maininclist );
459 2 : find_includes(filecontent, ip, ip, 0, FALSE, incCollection, includes);
460 2 : hash_free( includes );
461 :
462 2 : freefile(filecontent);
463 2 : recursive_pr_include(ip, ip->i_file, base_name(*fp));
464 2 : inc_clean();
465 : }
466 2 : if (printed)
467 0 : printf("\n");
468 :
469 2 : delete_IncludesCollection(incCollection);
470 :
471 2 : exit(0);
472 : }
473 :
474 11 : struct filepointer *getfile(file)
475 : char *file;
476 : {
477 : register int fd;
478 : struct filepointer *content;
479 : struct stat st;
480 : off_t size_backup;
481 : ssize_t bytes_read;
482 : size_t malloc_size;
483 :
484 11 : content = (struct filepointer *)malloc(sizeof(struct filepointer));
485 11 : if ((fd = open(file, O_RDONLY)) < 0) {
486 0 : warning("makedepend: Cannot open file \"%s\"\n", file);
487 0 : content->f_p = content->f_base = content->f_end = (char *)malloc(1);
488 0 : *content->f_p = '\0';
489 0 : return(content);
490 : }
491 11 : fstat(fd, &st);
492 :
493 11 : size_backup = st.st_size;
494 11 : malloc_size = size_backup;
495 : /* Since off_t is larger than size_t, need to test for
496 : * truncation.
497 : */
498 11 : if ( (off_t)malloc_size != size_backup )
499 : {
500 0 : close( fd );
501 0 : warning("makedepend: File \"%s\" size larger than can fit in size_t. Cannot allocate memory for contents.\n", file);
502 0 : content->f_p = content->f_base = content->f_end = (char *)malloc(1);
503 0 : *content->f_p = '\0';
504 0 : return(content);
505 : }
506 :
507 11 : content->f_base = (char *)malloc(malloc_size+1);
508 11 : if (content->f_base == NULL)
509 0 : fatalerr("makedepend: Cannot allocate memory to process file \"%s\"\n", file);
510 11 : if ((bytes_read = read(fd, content->f_base, malloc_size)) < 0)
511 0 : if ( st.st_mode & S_IFREG )
512 0 : fatalerr("makedepend: Failed to read file \"%s\"\n", file);
513 :
514 11 : close(fd);
515 11 : content->f_len = bytes_read+1;
516 11 : content->f_p = content->f_base;
517 11 : content->f_end = content->f_base + bytes_read;
518 11 : *content->f_end = '\0';
519 11 : content->f_line = 0;
520 11 : return(content);
521 : }
522 :
523 11 : void freefile(fp)
524 : struct filepointer *fp;
525 : {
526 11 : free(fp->f_base);
527 11 : free(fp);
528 11 : }
529 :
530 558 : char *copy(str)
531 : register char *str;
532 : {
533 558 : register char *p = (char *)malloc(strlen(str) + 1);
534 :
535 558 : strcpy(p, str);
536 558 : return(p);
537 : }
538 :
539 551 : int match(str, list)
540 : register char *str, **list;
541 : {
542 : register int i;
543 :
544 3029 : for (i=0; *list; i++, list++)
545 3029 : if (strcmp(str, *list) == 0)
546 551 : return(i);
547 0 : return(-1);
548 : }
549 :
550 : /*
551 : * Get the next line. We only return lines beginning with '#' since that
552 : * is all this program is ever interested in.
553 : */
554 562 : char *get_line(filep)
555 : register struct filepointer *filep;
556 : {
557 : register char *p, /* walking pointer */
558 : *eof, /* end of file pointer */
559 : *bol; /* beginning of line pointer */
560 : register int lineno; /* line number */
561 :
562 562 : p = filep->f_p;
563 562 : eof = filep->f_end;
564 562 : if (p >= eof)
565 0 : return((char *)NULL);
566 562 : lineno = filep->f_line;
567 :
568 49207 : for(bol = p--; ++p < eof; ) {
569 48634 : if (*p == '/' && *(p+1) == '*') { /* consume comments */
570 217 : *p++ = ' ', *p++ = ' ';
571 65327 : while (*p) {
572 65110 : if (*p == '*' && *(p+1) == '/') {
573 217 : *p++ = ' ', *p = ' ';
574 217 : break;
575 : }
576 64893 : else if (*p == '\n')
577 1549 : lineno++;
578 64893 : *p++ = ' ';
579 : }
580 217 : continue;
581 : }
582 48417 : else if (*p == '/' && *(p+1) == '/') { /* consume comments */
583 13 : *p++ = ' ', *p++ = ' ';
584 792 : while (*p && *p != '\n')
585 766 : *p++ = ' ';
586 13 : if ( *p == '\n' )
587 13 : p--;
588 13 : lineno++;
589 13 : continue;
590 : }
591 48404 : else if (*p == '\\') {
592 26 : if (*(p+1) == '\n') {
593 9 : *p = ' ';
594 9 : *(p+1) = ' ';
595 9 : lineno++;
596 : }
597 : }
598 48378 : else if (*p == '\n') {
599 1603 : lineno++;
600 1603 : if (*bol == '#') {
601 : register char *cp;
602 :
603 551 : *p++ = '\0';
604 : /* punt lines with just # (yacc generated) */
605 1425 : for (cp = bol+1;
606 1197 : *cp && (*cp == ' ' || *cp == '\t'); cp++);
607 551 : if (*cp) goto done;
608 : }
609 1052 : bol = p+1;
610 : }
611 : }
612 11 : if (*bol != '#')
613 11 : bol = NULL;
614 : done:
615 562 : filep->f_p = p;
616 562 : filep->f_line = lineno;
617 562 : return(bol);
618 : }
619 :
620 : /*
621 : * Strip the file name down to what we want to see in the Makefile.
622 : * It will have objprefix and objsuffix around it.
623 : */
624 2 : char *base_name(file)
625 : register char *file;
626 : {
627 : register char *p;
628 :
629 2 : file = copy(file);
630 2 : for(p=file+strlen(file); p>file && *p != '.'; p--) ;
631 :
632 2 : if (*p == '.')
633 2 : *p = '\0';
634 :
635 22 : while (p > file) {
636 18 : if ( *p == '/' || *p == '\\') {
637 0 : file = p + 1;
638 0 : break;
639 : };
640 18 : p--;
641 : };
642 2 : return(file);
643 : }
644 :
645 : #if defined(USG) && !defined(CRAY) && !defined(SVR4)
646 : int rename (from, to)
647 : char *from, *to;
648 : {
649 : (void) unlink (to);
650 : if (link (from, to) == 0) {
651 : unlink (from);
652 : return 0;
653 : } else {
654 : return -1;
655 : }
656 : }
657 : #endif /* USGISH */
658 :
659 2 : void redirect(line, makefile)
660 : char *line,
661 : *makefile;
662 : {
663 : struct stat st;
664 : FILE *fdin, *fdout;
665 : char backup[ BUFSIZ ],
666 : buf[ BUFSIZ ];
667 2 : boolean found = FALSE;
668 : int len;
669 :
670 : /*
671 : * if makefile is "-" then let it pour onto stdout.
672 : */
673 2 : if (makefile && *makefile == '-' && *(makefile+1) == '\0')
674 2 : return;
675 :
676 : /*
677 : * use a default makefile is not specified.
678 : */
679 0 : if (!makefile) {
680 0 : if (stat("Makefile", &st) == 0)
681 0 : makefile = "Makefile";
682 0 : else if (stat("makefile", &st) == 0)
683 0 : makefile = "makefile";
684 : else
685 0 : fatalerr("[mM]akefile is not present\n");
686 : }
687 : else
688 0 : stat(makefile, &st);
689 0 : if ((fdin = fopen(makefile, "r")) == NULL)
690 0 : fatalerr("cannot open \"%s\"\n", makefile);
691 0 : sprintf(backup, "%s.bak", makefile);
692 0 : unlink(backup);
693 : #if defined(WIN32)
694 : fclose(fdin);
695 : #endif
696 0 : if (rename(makefile, backup) < 0)
697 0 : fatalerr("cannot rename %s to %s\n", makefile, backup);
698 : #if defined(WIN32)
699 : if ((fdin = fopen(backup, "r")) == NULL)
700 : fatalerr("cannot open \"%s\"\n", backup);
701 : #endif
702 0 : if ((fdout = freopen(makefile, "w", stdout)) == NULL)
703 0 : fatalerr("cannot open \"%s\"\n", backup);
704 0 : len = strlen(line);
705 0 : while (!found && fgets(buf, BUFSIZ, fdin)) {
706 0 : if (*buf == '#' && strncmp(line, buf, len) == 0)
707 0 : found = TRUE;
708 0 : fputs(buf, fdout);
709 : }
710 0 : if (!found) {
711 0 : if (verbose)
712 0 : warning("Adding new delimiting line \"%s\" and dependencies...\n",
713 : line);
714 0 : puts(line); /* same as fputs(fdout); but with newline */
715 0 : } else if (append) {
716 0 : while (fgets(buf, BUFSIZ, fdin)) {
717 0 : fputs(buf, fdout);
718 : }
719 : }
720 0 : fflush(fdout);
721 : #if defined(USGISH) || defined(USE_CHMOD)
722 : chmod(makefile, st.st_mode);
723 : #else
724 0 : fchmod(fileno(fdout), st.st_mode);
725 : #endif /* USGISH */
726 0 : fclose(fdin);
727 : }
728 :
729 0 : void fatalerr(char *msg, ...)
730 : {
731 : va_list args;
732 0 : fprintf(stderr, "%s: error: ", ProgramName);
733 0 : va_start(args, msg);
734 0 : vfprintf(stderr, msg, args);
735 0 : va_end(args);
736 0 : exit (1);
737 : }
738 :
739 13 : void warning(char *msg, ...)
740 : {
741 : #ifdef DEBUG_MKDEPEND
742 : va_list args;
743 : fprintf(stderr, "%s: warning: ", ProgramName);
744 : va_start(args, msg);
745 : vfprintf(stderr, msg, args);
746 : va_end(args);
747 : #else
748 : (void)msg;
749 : #endif /* DEBUG_MKDEPEND */
750 13 : }
751 :
752 130 : void warning1(char *msg, ...)
753 : {
754 : #ifdef DEBUG_MKDEPEND
755 : va_list args;
756 : va_start(args, msg);
757 : vfprintf(stderr, msg, args);
758 : va_end(args);
759 : #else
760 : (void)msg;
761 : #endif /* DEBUG_MKDEPEND */
762 130 : }
763 :
764 299 : void convert_slashes(path)
765 : char* path;
766 : {
767 : #if defined (WNT)
768 : /*
769 : * Convert backslashes to slashes
770 : */
771 : char *ptr;
772 : if (native_win_slashes) {
773 : for (ptr = (char*)path; *ptr; ++ptr)
774 : if (*ptr == '/')
775 : *ptr = '\\';
776 : } else {
777 : for (ptr = (char*)path; *ptr; ++ptr)
778 : if (*ptr == '\\')
779 : *ptr = '/';
780 : };
781 : #else
782 : (void)path;
783 : #endif
784 299 : }
785 :
786 2 : char* append_slash(path)
787 : char* path;
788 : {
789 : char *new_string;
790 2 : if ((path[strlen(path) - 1] == '/') || (path[strlen(path) - 1] == '\\')) {
791 0 : new_string = path;
792 : } else {
793 2 : new_string = (char*)malloc(sizeof(char) * (strlen(path) + 2));
794 2 : strcpy(new_string, path);
795 2 : if (native_win_slashes)
796 0 : strcat(new_string, "\\");
797 : else
798 2 : strcat(new_string, "/");
799 : };
800 2 : return new_string;
801 : }
802 :
803 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
