/[jscoverage]/trunk/js/config/mkdepend/main.c
ViewVC logotype

Contents of /trunk/js/config/mkdepend/main.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 399 - (show annotations)
Tue Dec 9 03:37:47 2008 UTC (13 years, 5 months ago) by siliconforks
File MIME type: text/plain
File size: 19250 byte(s)
Use SpiderMonkey from Firefox 3.1b2.

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

  ViewVC Help
Powered by ViewVC 1.1.24