|
0
|
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, 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
|
