OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [fixincludes/] [fixfixes.c] - Blame information for rev 280

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.