OSDN Git Service

Use one makefile for fixinc
[pf3gnuchains/gcc-fork.git] / gcc / fixinc / fixfixes.c
1
2 /*
3
4    Test to see if a particular fix should be applied to a header file.
5
6    Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
7
8 = = = = = = = = = = = = = = = = = = = = = = = = =
9
10 NOTE TO DEVELOPERS
11
12 The routines you write here must work closely with fixincl.c.
13
14 Here are the rules:
15
16 1.  Every test procedure name must be suffixed with "_fix".
17     These routines will be referenced from inclhack.def, sans the suffix.
18
19 2.  Use the "FIX_PROC_HEAD()" macro _with_ the "_fix" suffix
20     (I cannot use the ## magic from ANSI C) for defining your entry point.
21
22 3.  Put your test name into the FIXUP_TABLE.
23
24 4.  Do not read anything from stdin.  It is closed.
25
26 5.  Write to stderr only in the event of a reportable error
27     In such an event, call "exit (EXIT_FAILURE)".
28
29 6.  You have access to the fixDescList entry for the fix in question.
30     This may be useful, for example, if there are interesting strings
31     or pre-compiled regular expressions stored there.
32
33     It is also possible to access fix descriptions by using the
34     index of a known fix, "my_fix_name" for example:
35
36         tFixDesc*  p_desc  = fixDescList + MY_FIX_NAME_FIXIDX;
37         tTestDesc* p_tlist = p_desc->p_test_desc;
38
39         regexec (p_tlist->p_test_regex, ...)
40
41 = = = = = = = = = = = = = = = = = = = = = = = = =
42
43 This file is part of GNU CC.
44
45 GNU CC is free software; you can redistribute it and/or modify
46 it under the terms of the GNU General Public License as published by
47 the Free Software Foundation; either version 2, or (at your option)
48 any later version.
49
50 GNU CC is distributed in the hope that it will be useful,
51 but WITHOUT ANY WARRANTY; without even the implied warranty of
52 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
53 GNU General Public License for more details.
54
55 You should have received a copy of the GNU General Public License
56 along with GNU CC; see the file COPYING.  If not, write to
57 the Free Software Foundation, 59 Temple Place - Suite 330,
58 Boston, MA 02111-1307, USA.  */
59
60 #include "fixlib.h"
61 #define    GTYPE_SE_CT 1
62
63 #ifdef SEPARATE_FIX_PROC
64 #include "fixincl.x"
65 #endif
66
67 tSCC zNeedsArg[] = "fixincl error:  `%s' needs %s argument (c_fix_arg[%d])\n";
68
69 typedef void t_fix_proc PARAMS ((const char *, const char *, tFixDesc *));
70 typedef struct {
71     const char*  fix_name;
72     t_fix_proc*  fix_proc;
73 } fix_entry_t;
74
75 #define FIXUP_TABLE \
76   _FT_( "char_macro_def",   char_macro_def_fix ) \
77   _FT_( "char_macro_use",   char_macro_use_fix ) \
78   _FT_( "format",           format_fix )         \
79   _FT_( "machine_name",     machine_name_fix )   \
80   _FT_( "wrap",             wrap_fix )           \
81   _FT_( "gnu_type",         gnu_type_fix )
82
83
84 #define FIX_PROC_HEAD( fix )                    \
85 static void fix PARAMS ((const char *, const char *, tFixDesc *)); /* avoid warning */      \
86 static void fix ( filname, text, p_fixd )       \
87     const char* filname;                        \
88     const char* text;                           \
89     tFixDesc* p_fixd;
90
91 #ifdef NEED_PRINT_QUOTE
92 /*
93  *  Skip over a quoted string.  Single quote strings may
94  *  contain multiple characters if the first character is
95  *  a backslash.  Especially a backslash followed by octal digits.
96  *  We are not doing a correctness syntax check here.
97  */
98 static char*
99 print_quote( q, text )
100   char  q;
101   char* text;
102 {
103   fputc( q, stdout );
104
105   for (;;)
106     {
107       char ch = *(text++);
108       fputc( ch, stdout );
109
110       switch (ch)
111         {
112         case '\\':
113           if (*text == NUL)
114             goto quote_done;
115
116           fputc( *(text++), stdout );
117           break;
118
119         case '"':
120         case '\'':
121           if (ch != q)
122             break;
123           /*FALLTHROUGH*/
124
125         case '\n':
126         case NUL:
127           goto quote_done;
128         }
129     } quote_done:;
130
131   return text;
132 }
133 #endif /* NEED_PRINT_QUOTE */
134
135
136 /*
137  *  Emit the GNU standard type wrapped up in such a way that
138  *  this thing can be encountered countless times during a compile
139  *  and not cause even a warning.
140  */
141 static const char *emit_gnu_type PARAMS ((const char *, regmatch_t *));
142 static const char*
143 emit_gnu_type ( text, rm )
144   const char* text;
145   regmatch_t* rm;
146 {
147   char z_TYPE[ 64 ];
148   char z_type[ 64 ];
149
150   fwrite (text, rm[0].rm_so, 1, stdout);
151
152   {
153     const char* ps = text   + rm[1].rm_so;
154     const char* pe = text   + rm[1].rm_eo;
155     char* pd = z_type;
156     char* pD = z_TYPE;
157
158     while (ps < pe)
159       *(pD++) = TOUPPER( *(pd++) = *(ps++) );
160
161     *pD = *pd = NUL;
162   }
163
164   /*
165    *  Now print out the reformed typedef,
166    *  with a C++ guard for WCHAR
167    */
168   {
169     tSCC z_fmt[] = "\
170 #if !defined(_GCC_%s_T)%s\n\
171 #define _GCC_%s_T\n\
172 typedef __%s_TYPE__ %s_t;\n\
173 #endif\n";
174
175     const char* pz_guard = (strcmp (z_type, "wchar") == 0)
176                            ? " && ! defined(__cplusplus)" : "";
177
178     printf (z_fmt, z_TYPE, pz_guard, z_TYPE, z_TYPE, z_type);
179   }
180
181   return text += rm[0].rm_eo;
182 }
183
184
185 /*
186  *  Copy the `format' string to std out, replacing `%n' expressions
187  *  with the matched text from a regular expression evaluation.
188  *  Doubled '%' characters will be replaced with a single copy.
189  *  '%' characters in other contexts and all other characters are
190  *  copied out verbatim.
191  */
192 static void format_write PARAMS ((tCC *, tCC *, regmatch_t[]));
193 static void
194 format_write (format, text, av)
195      tCC* format;
196      tCC* text;
197      regmatch_t av[];
198 {
199   int c;
200
201   while ((c = (unsigned)*(format++)) != NUL) {
202
203     if (c != '%')
204       {
205         putchar(c);
206         continue;
207       }
208
209     c = (unsigned)*(format++);
210
211     /*
212      *  IF the character following a '%' is not a digit,
213      *  THEN we will always emit a '%' and we may or may
214      *  not emit the following character.  We will end on
215      *  a NUL and we will emit only one of a pair of '%'.
216      */
217     if (! ISDIGIT ( c ))
218       {
219         putchar( '%' );
220         switch (c) {
221         case NUL:
222           return;
223         case '%':
224           break;
225         default:
226           putchar(c);
227         }
228       }
229
230     /*
231      *  Emit the matched subexpression numbered 'c'.
232      *  IF, of course, there was such a match...
233      */
234     else {
235       regmatch_t*  pRM = av + (c - (unsigned)'0');
236       size_t len;
237
238       if (pRM->rm_so < 0)
239         continue;
240
241       len = pRM->rm_eo - pRM->rm_so;
242       if (len > 0)
243         fwrite(text + pRM->rm_so, len, 1, stdout);
244     }
245   }
246 }
247
248
249 /*
250  *  Search for multiple copies of a regular expression.  Each block
251  *  of matched text is replaced with the format string, as described
252  *  above in `format_write'.
253  */
254 FIX_PROC_HEAD( format_fix )
255 {
256   tCC*  pz_pat = p_fixd->patch_args[2];
257   tCC*  pz_fmt = p_fixd->patch_args[1];
258   regex_t re;
259   regmatch_t rm[10];
260   IGNORE_ARG(filname);
261
262   /*
263    *  We must have a format
264    */
265   if (pz_fmt == (tCC*)NULL)
266     {
267       fprintf( stderr, zNeedsArg, p_fixd->fix_name, "replacement format", 0 );
268       exit (EXIT_BROKEN);
269     }
270
271   /*
272    *  IF we don't have a search text, then go find the first
273    *  regular expression among the tests.
274    */
275   if (pz_pat == (tCC*)NULL)
276     {
277       tTestDesc* pTD = p_fixd->p_test_desc;
278       int        ct  = p_fixd->test_ct;
279       for (;;)
280         {
281           if (ct-- <= 0)
282             {
283               fprintf( stderr, zNeedsArg, p_fixd->fix_name, "search text", 1 );
284               exit (EXIT_BROKEN);
285             }
286
287           if (pTD->type == TT_EGREP)
288             {
289               pz_pat = pTD->pz_test_text;
290               break;
291             }
292
293           pTD++;
294         }
295     }
296
297   /*
298    *  Replace every copy of the text we find
299    */
300   compile_re (pz_pat, &re, 1, "format search-text", "format_fix" );
301   while (regexec (&re, text, 10, rm, 0) == 0)
302     {
303       fwrite( text, rm[0].rm_so, 1, stdout );
304       format_write( pz_fmt, text, rm );
305       text += rm[0].rm_eo;
306     }
307
308   /*
309    *  Dump out the rest of the file
310    */
311   fputs (text, stdout);
312 }
313
314
315 /* Scan the input file for all occurrences of text like this:
316
317    #define TIOCCONS _IO(T, 12)
318
319    and change them to read like this:
320
321    #define TIOCCONS _IO('T', 12)
322
323    which is the required syntax per the C standard.  (The definition of
324    _IO also has to be tweaked - see below.)  'IO' is actually whatever you
325    provide as the `c_fix_arg' argument.  */
326
327 FIX_PROC_HEAD( char_macro_use_fix )
328 {
329   /* This regexp looks for a traditional-syntax #define (# in column 1)
330      of an object-like macro.  */
331   static const char pat[] =
332     "^#[ \t]*define[ \t]+[_A-Za-z][_A-Za-z0-9]*[ \t]+";
333   static regex_t re;
334
335   const char* str = p_fixd->patch_args[1];
336   regmatch_t rm[1];
337   const char *p, *limit;
338   size_t len;
339   IGNORE_ARG(filname);
340
341   if (str == NULL)
342     {
343       fprintf (stderr, zNeedsArg, p_fixd->fix_name, "ioctl type", 0);
344       exit (EXIT_BROKEN);
345     }
346
347   len = strlen (str);
348   compile_re (pat, &re, 1, "macro pattern", "char_macro_use_fix");
349
350   for (p = text;
351        regexec (&re, p, 1, rm, 0) == 0;
352        p = limit + 1)
353     {
354       /* p + rm[0].rm_eo is the first character of the macro replacement.
355          Find the end of the macro replacement, and the STR we were
356          sent to look for within the replacement.  */
357       p += rm[0].rm_eo;
358       limit = p - 1;
359       do
360         {
361           limit = strchr (limit + 1, '\n');
362           if (!limit)
363             goto done;
364         }
365       while (limit[-1] == '\\');
366
367       do
368         {
369           if (*p == str[0] && !strncmp (p+1, str+1, len-1))
370             goto found;
371         }
372       while (++p < limit - len);
373       /* Hit end of line.  */
374       continue;
375
376     found:
377       /* Found STR on this line.  If the macro needs fixing,
378          the next few chars will be whitespace or uppercase,
379          then an open paren, then a single letter.  */
380       while ((ISSPACE (*p) || ISUPPER (*p)) && p < limit) p++;
381       if (*p++ != '(')
382         continue;
383       if (!ISALPHA (*p))
384         continue;
385       if (ISALNUM (p[1]) || p[1] == '_')
386         continue;
387
388       /* Splat all preceding text into the output buffer,
389          quote the character at p, then proceed.  */
390       fwrite (text, 1, p - text, stdout);
391       putchar ('\'');
392       putchar (*p);
393       putchar ('\'');
394       text = p + 1;
395     }
396  done:
397   fputs (text, stdout);
398 }
399
400
401 /* Scan the input file for all occurrences of text like this:
402
403    #define xxxIOxx(x, y) (....'x'<<16....)
404
405    and change them to read like this:
406
407    #define xxxIOxx(x, y) (....x<<16....)
408
409    which is the required syntax per the C standard.  (The uses of _IO
410    also has to be tweaked - see above.)  'IO' is actually whatever
411    you provide as the `c_fix_arg' argument.  */
412 FIX_PROC_HEAD( char_macro_def_fix )
413 {
414   /* This regexp looks for any traditional-syntax #define (# in column 1).  */
415   static const char pat[] =
416     "^#[ \t]*define[ \t]+";
417   static regex_t re;
418
419   const char* str = p_fixd->patch_args[1];
420   regmatch_t rm[1];
421   const char *p, *limit;
422   char arg;
423   size_t len;
424   IGNORE_ARG(filname);
425
426   if (str == NULL)
427     {
428       fprintf (stderr, zNeedsArg, p_fixd->fix_name, "ioctl type", 0);
429       exit (EXIT_BROKEN);
430     }
431
432   len = strlen (str);
433   compile_re (pat, &re, 1, "macro pattern", "fix_char_macro_defines");
434
435   for (p = text;
436        regexec (&re, p, 1, rm, 0) == 0;
437        p = limit + 1)
438     {
439       /* p + rm[0].rm_eo is the first character of the macro name.
440          Find the end of the macro replacement, and the STR we were
441          sent to look for within the name.  */
442       p += rm[0].rm_eo;
443       limit = p - 1;
444       do
445         {
446           limit = strchr (limit + 1, '\n');
447           if (!limit)
448             goto done;
449         }
450       while (limit[-1] == '\\');
451
452       do
453         {
454           if (*p == str[0] && !strncmp (p+1, str+1, len-1))
455             goto found;
456           p++;
457         }
458       while (ISALPHA (*p) || ISALNUM (*p) || *p == '_');
459       /* Hit end of macro name without finding the string.  */
460       continue;
461
462     found:
463       /* Found STR in this macro name.  If the macro needs fixing,
464          there may be a few uppercase letters, then there will be an
465          open paren with _no_ intervening whitespace, and then a
466          single letter.  */
467       while (ISUPPER (*p) && p < limit) p++;
468       if (*p++ != '(')
469         continue;
470       if (!ISALPHA (*p))
471         continue;
472       if (ISALNUM (p[1]) || p[1] == '_')
473         continue;
474
475       /* The character at P is the one to look for in the following
476          text.  */
477       arg = *p;
478       p += 2;
479
480       while (p < limit)
481         {
482           if (p[-1] == '\'' && p[0] == arg && p[1] == '\'')
483             {
484               /* Remove the quotes from this use of ARG.  */
485               p--;
486               fwrite (text, 1, p - text, stdout);
487               putchar (arg);
488               p += 3;
489               text = p;
490             }
491           else
492             p++;
493         }
494     }
495  done:
496   fputs (text, stdout);
497 }
498
499 /* Fix for machine name #ifdefs that are not in the namespace reserved
500    by the C standard.  They won't be defined if compiling with -ansi,
501    and the headers will break.  We go to some trouble to only change
502    #ifdefs where the macro is defined by GCC in non-ansi mode; this
503    minimizes the number of headers touched.  */
504
505 #define SCRATCHSZ 64   /* hopefully long enough */
506
507 FIX_PROC_HEAD( machine_name_fix )
508 {
509 #ifndef MN_NAME_PAT
510   fputs( "The target machine has no needed machine name fixes\n", stderr );
511 #else
512   regmatch_t match[2];
513   const char *line, *base, *limit, *p, *q;
514   regex_t *label_re, *name_re;
515   char scratch[SCRATCHSZ];
516   size_t len;
517   IGNORE_ARG(filname);
518   IGNORE_ARG(p_fixd);
519
520   mn_get_regexps (&label_re, &name_re, "machine_name_fix");
521
522   scratch[0] = '_';
523   scratch[1] = '_';
524
525   for (base = text;
526        regexec (label_re, base, 2, match, 0) == 0;
527        base = limit)
528     {
529       base += match[0].rm_eo;
530       /* We're looking at an #if or #ifdef.  Scan forward for the
531          next non-escaped newline.  */
532       line = limit = base;
533       do
534         {
535           limit++;
536           limit = strchr (limit, '\n');
537           if (!limit)
538             goto done;
539         }
540       while (limit[-1] == '\\');
541
542       /* If the 'name_pat' matches in between base and limit, we have
543          a bogon.  It is not worth the hassle of excluding comments
544          because comments on #if/#ifdef lines are rare, and strings on
545          such lines are illegal.
546
547          REG_NOTBOL means 'base' is not at the beginning of a line, which
548          shouldn't matter since the name_re has no ^ anchor, but let's
549          be accurate anyway.  */
550
551       for (;;)
552         {
553         again:
554           if (base == limit)
555             break;
556
557           if (regexec (name_re, base, 1, match, REG_NOTBOL))
558             goto done;  /* No remaining match in this file */
559
560           /* Match; is it on the line?  */
561           if (match[0].rm_eo > limit - base)
562             break;
563
564           p = base + match[0].rm_so;
565           base += match[0].rm_eo;
566
567           /* One more test: if on the same line we have the same string
568              with the appropriate underscores, then leave it alone.
569              We want exactly two leading and trailing underscores.  */
570           if (*p == '_')
571             {
572               len = base - p - ((*base == '_') ? 2 : 1);
573               q = p + 1;
574             }
575           else
576             {
577               len = base - p - ((*base == '_') ? 1 : 0);
578               q = p;
579             }
580           if (len + 4 > SCRATCHSZ)
581             abort ();
582           memcpy (&scratch[2], q, len);
583           len += 2;
584           scratch[len++] = '_';
585           scratch[len++] = '_';
586
587           for (q = line; q <= limit - len; q++)
588             if (*q == '_' && !strncmp (q, scratch, len))
589               goto again;
590           
591           fwrite (text, 1, p - text, stdout);
592           fwrite (scratch, 1, len, stdout);
593
594           text = base;
595         }
596     }
597  done:
598 #endif
599   fputs (text, stdout);
600 }
601
602
603 FIX_PROC_HEAD( wrap_fix )
604 {
605   tSCC   z_no_wrap_pat[] = "^#if.*__need_";
606   static regex_t no_wrapping_re; /* assume zeroed data */
607
608   char   z_fixname[ 64 ];
609   tCC*   pz_src  = p_fixd->fix_name;
610   tCC*   pz_name = z_fixname;
611   char*  pz_dst  = z_fixname;
612   int    do_end  = 0;
613   size_t len     = 0;
614   IGNORE_ARG(filname);
615
616   if (no_wrapping_re.allocated == 0)
617     compile_re( z_no_wrap_pat, &no_wrapping_re, 0, "no-wrap pattern",
618                 "wrap-fix" );
619
620   for (;;) {
621     char ch = *pz_src++;
622
623     if (ch == NUL) {
624       *pz_dst++ = ch;
625       break;
626     } else if (! ISALNUM (ch)) {
627       *pz_dst++ = '_';
628     } else {
629       *pz_dst++ = TOUPPER (ch);
630     }
631
632     if (++len >= sizeof( z_fixname )) {
633       void* p = xmalloc( len + strlen( pz_src ) + 1 );
634       memcpy( p, (void*)z_fixname, len );
635       pz_name = (tCC*)p;
636       pz_dst  = (char*)pz_name + len;
637     }
638   }
639
640   /*
641    *  IF we do *not* match the no-wrap re, then we have a double negative.
642    *  A double negative means YES.
643    */
644   if (regexec (&no_wrapping_re, text, 0, NULL, 0) != 0)
645     {
646       printf( "#ifndef FIXINC_%s_CHECK\n", pz_name );
647       printf( "#define FIXINC_%s_CHECK 1\n\n", pz_name );
648       do_end = 1;
649     }
650
651   if (p_fixd->patch_args[1] == (tCC*)NULL)
652     fputs( text, stdout );
653
654   else {
655     fputs( p_fixd->patch_args[1], stdout );
656     fputs( text, stdout );
657     if (p_fixd->patch_args[2] != (tCC*)NULL)
658       fputs( p_fixd->patch_args[2], stdout );
659   }
660
661   if (do_end != 0)
662     printf( "\n#endif  /* FIXINC_%s_CHECK */\n", pz_name );
663
664   if (pz_name != z_fixname)
665     free( (void*)pz_name );
666 }
667
668
669 /*
670  *  Search for multiple copies of a regular expression.  Each block
671  *  of matched text is replaced with the format string, as described
672  *  above in `format_write'.
673  */
674 FIX_PROC_HEAD( gnu_type_fix )
675 {
676   const char* pz_pat;
677   regex_t    re;
678   regmatch_t rm[GTYPE_SE_CT+1];
679   IGNORE_ARG(filname);
680
681   {
682     tTestDesc* pTD = p_fixd->p_test_desc;
683     int        ct  = p_fixd->test_ct;
684     for (;;)
685       {
686         if (ct-- <= 0)
687           {
688             fprintf (stderr, zNeedsArg, p_fixd->fix_name, "search text", 1);
689             exit (EXIT_BROKEN);
690           }
691
692         if (pTD->type == TT_EGREP)
693           {
694             pz_pat = pTD->pz_test_text;
695             break;
696           }
697
698         pTD++;
699       }
700   }
701
702   compile_re (pz_pat, &re, 1, "gnu type typedef", "gnu_type_fix");
703
704   while (regexec (&re, text, GTYPE_SE_CT+1, rm, 0) == 0)
705     {
706       text = emit_gnu_type (text, rm);
707     }
708
709   /*
710    *  Dump out the rest of the file
711    */
712   fputs (text, stdout);
713 }
714
715
716 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
717
718      test for fix selector
719
720      THIS IS THE ONLY EXPORTED ROUTINE
721
722 */
723 void
724 apply_fix( p_fixd, filname )
725   tFixDesc* p_fixd;
726   tCC* filname;
727 {
728 #define _FT_(n,p) { n, p },
729   static fix_entry_t fix_table[] = { FIXUP_TABLE { NULL, NULL }};
730 #undef _FT_
731 #define FIX_TABLE_CT (ARRAY_SIZE (fix_table)-1)
732
733   tCC* fixname = p_fixd->patch_args[0];
734   char* buf;
735   int ct = FIX_TABLE_CT;
736   fix_entry_t* pfe = fix_table;
737
738   for (;;)
739     {
740       if (strcmp (pfe->fix_name, fixname) == 0)
741         break;
742       if (--ct <= 0)
743         {
744           fprintf (stderr, "fixincl error:  the `%s' fix is unknown\n",
745                    fixname );
746           exit (EXIT_BROKEN);
747         }
748       pfe++;
749     }
750
751   buf = load_file_data (stdin);
752   (*pfe->fix_proc)( filname, buf, p_fixd );
753 }
754
755 #ifdef SEPARATE_FIX_PROC
756 tSCC z_usage[] =
757 "USAGE: applyfix <fix-name> <file-to-fix> <file-source> <file-destination>\n";
758 tSCC z_reopen[] =
759 "FS error %d (%s) reopening %s as std%s\n";
760
761 int
762 main( argc, argv )
763   int     argc;
764   char**  argv;
765 {
766   tFixDesc* pFix;
767   char* pz_tmptmp;
768   char* pz_tmp_base;
769   char* pz_tmp_dot;
770
771   if (argc != 5)
772     {
773     usage_failure:
774       fputs (z_usage, stderr);
775       return EXIT_FAILURE;
776     }
777
778   {
779     char* pz = argv[1];
780     long  idx;
781
782     if (! ISDIGIT ( *pz ))
783       goto usage_failure;
784
785     idx = strtol (pz, &pz, 10);
786     if ((*pz != NUL) || ((unsigned)idx >= FIX_COUNT))
787       goto usage_failure;
788     pFix = fixDescList + idx;
789   }
790
791   if (freopen (argv[3], "r", stdin) != stdin)
792     {
793       fprintf (stderr, z_reopen, errno, strerror( errno ), argv[3], "in");
794       return EXIT_FAILURE;
795     }
796
797   pz_tmptmp = (char*)xmalloc( strlen( argv[4] ) + 5 );
798   strcpy( pz_tmptmp, argv[4] );
799
800   /* Don't lose because "12345678" and "12345678X" map to the same
801      file under DOS restricted 8+3 file namespace.  Note that DOS
802      doesn't allow more than one dot in the trunk of a file name.  */
803   pz_tmp_base = basename( pz_tmptmp );
804   pz_tmp_dot = strchr( pz_tmp_base, '.' );
805   if (pathconf( pz_tmptmp, _PC_NAME_MAX ) <= 12 /* is this DOS or Windows9X? */
806       && pz_tmp_dot != (char*)NULL)
807     strcpy (pz_tmp_dot+1, "X"); /* nuke the original extension */
808   else
809     strcat (pz_tmptmp, ".X");
810   if (freopen (pz_tmptmp, "w", stdout) != stdout)
811     {
812       fprintf (stderr, z_reopen, errno, strerror( errno ), pz_tmptmp, "out");
813       return EXIT_FAILURE;
814     }
815
816   apply_fix (pFix, argv[1]);
817   fclose (stdout);
818   fclose (stdin);
819   unlink (argv[4]);
820   if (rename (pz_tmptmp, argv[4]) != 0)
821     {
822       fprintf (stderr, "error %d (%s) renaming %s to %s\n", errno,
823                strerror( errno ), pz_tmptmp, argv[4]);
824       return EXIT_FAILURE;
825     }
826
827   return EXIT_SUCCESS;
828 }
829 #endif