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