]>
Dogcows Code - chaz/tar/blob - src/ansi2knr.c
1 /* Copyright (C) 1989, 1997, 1998, 1999 Aladdin Enterprises. All rights reserved. */
4 /* Convert ANSI C function definitions to K&R ("traditional C") syntax */
7 ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
8 WARRANTY. No author or distributor accepts responsibility to anyone for the
9 consequences of using it or for whether it serves any particular purpose or
10 works at all, unless he says so in writing. Refer to the GNU General Public
11 License (the "GPL") for full details.
13 Everyone is granted permission to copy, modify and redistribute ansi2knr,
14 but only under the conditions described in the GPL. A copy of this license
15 is supposed to have been given to you along with ansi2knr so you can know
16 your rights and responsibilities. It should be in a file named COPYLEFT,
17 or, if there is no file named COPYLEFT, a file named COPYING. Among other
18 things, the copyright notice and this notice must be preserved on all
21 We explicitly state here what we believe is already implied by the GPL: if
22 the ansi2knr program is distributed as a separate set of sources and a
23 separate executable file which are aggregated on a storage medium together
24 with another program, this in itself does not bring the other program under
25 the GPL, nor does the mere fact that such a program or the procedures for
26 constructing it invoke the ansi2knr executable bring any other part of the
27 program under the GPL.
32 ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]
33 * --filename provides the file name for the #line directive in the output,
34 * overriding input_file (if present).
35 * If no input_file is supplied, input is read from stdin.
36 * If no output_file is supplied, output goes to stdout.
37 * There are no error messages.
39 * ansi2knr recognizes function definitions by seeing a non-keyword
40 * identifier at the left margin, followed by a left parenthesis, with a
41 * right parenthesis as the last character on the line, and with a left
42 * brace as the first token on the following line (ignoring possible
43 * intervening comments and/or preprocessor directives), except that a line
45 * identifier1(identifier2)
46 * will not be considered a function definition unless identifier2 is
47 * the word "void", and a line consisting of
48 * identifier1(identifier2, <<arbitrary>>)
49 * will not be considered a function definition.
50 * ansi2knr will recognize a multi-line header provided that no intervening
51 * line ends with a left or right brace or a semicolon. These algorithms
52 * ignore whitespace, comments, and preprocessor directives, except that
53 * the function name must be the first thing on the line. The following
54 * constructs will confuse it:
55 * - Any other construct that starts at the left margin and
56 * follows the above syntax (such as a macro or function call).
57 * - Some macros that tinker with the syntax of function headers.
61 * The original and principal author of ansi2knr is L. Peter Deutsch
62 * <ghost@aladdin.com>. Other authors are noted in the change history
63 * that follows (in reverse chronological order):
64 lpd 1999-08-17 added code to allow preprocessor directives
65 wherever comments are allowed
66 lpd 1999-04-12 added minor fixes from Pavel Roskin
67 <pavel_roskin@geocities.com> for clean compilation with
69 lpd 1999-03-22 added hack to recognize lines consisting of
70 identifier1(identifier2, xxx) as *not* being procedures
71 lpd 1999-02-03 made indentation of preprocessor commands consistent
72 lpd 1999-01-28 fixed two bugs: a '/' in an argument list caused an
73 endless loop; quoted strings within an argument list
75 lpd 1999-01-24 added a check for write errors on the output,
76 suggested by Jim Meyering <meyering@ascend.com>
77 lpd 1998-11-09 added further hack to recognize identifier(void)
79 lpd 1998-10-23 added hack to recognize lines consisting of
80 identifier1(identifier2) as *not* being procedures
81 lpd 1997-12-08 made input_file optional; only closes input and/or
82 output file if not stdin or stdout respectively; prints
83 usage message on stderr rather than stdout; adds
84 --filename switch (changes suggested by
85 <ceder@lysator.liu.se>)
86 lpd 1996-01-21 added code to cope with not HAVE_CONFIG_H and with
87 compilers that don't understand void, as suggested by
89 lpd 1996-01-15 changed to require that the first non-comment token
90 on the line following a function header be a left brace,
91 to reduce sensitivity to macros, as suggested by Tom Lane
93 lpd 1995-06-22 removed #ifndefs whose sole purpose was to define
94 undefined preprocessor symbols as 0; changed all #ifdefs
95 for configuration symbols to #ifs
96 lpd 1995-04-05 changed copyright notice to make it clear that
97 including ansi2knr in a program does not bring the entire
99 lpd 1994-12-18 added conditionals for systems where ctype macros
100 don't handle 8-bit characters properly, suggested by
101 Francois Pinard <pinard@iro.umontreal.ca>;
102 removed --varargs switch (this is now the default)
103 lpd 1994-10-10 removed CONFIG_BROKETS conditional
104 lpd 1994-07-16 added some conditionals to help GNU `configure',
105 suggested by Francois Pinard <pinard@iro.umontreal.ca>;
106 properly erase prototype args in function parameters,
107 contributed by Jim Avera <jima@netcom.com>;
108 correct error in writeblanks (it shouldn't erase EOLs)
109 lpd 1989-xx-xx original version
112 /* Most of the conditionals here are to make ansi2knr work with */
113 /* or without the GNU configure machinery. */
125 For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
126 This will define HAVE_CONFIG_H and so, activate the following lines.
129 # if STDC_HEADERS || HAVE_STRING_H
132 # include <strings.h>
135 #else /* not HAVE_CONFIG_H */
137 /* Otherwise do it the hard way */
140 # include <strings.h>
143 extern int strlen(), strncmp();
149 #endif /* not HAVE_CONFIG_H */
155 malloc and free should be declared in stdlib.h,
156 but if you've got a K&R compiler, they probably aren't.
162 extern char *malloc();
165 extern char *malloc();
172 /* Define NULL (for *very* old compilers). */
178 * The ctype macros don't always handle 8-bit characters correctly.
179 * Compensate for this here.
182 # undef HAVE_ISASCII /* just in case */
183 # define HAVE_ISASCII 1
186 #if STDC_HEADERS || !HAVE_ISASCII
187 # define is_ascii(c) 1
189 # define is_ascii(c) isascii(c)
192 #define is_space(c) (is_ascii(c) && isspace(c))
193 #define is_alpha(c) (is_ascii(c) && isalpha(c))
194 #define is_alnum(c) (is_ascii(c) && isalnum(c))
196 /* Scanning macros */
197 #define isidchar(ch) (is_alnum(ch) || (ch) == '_')
198 #define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')
200 /* Forward references */
201 char *ppdirforward();
202 char *ppdirbackward();
209 /* The main program */
217 char *program_name
= argv
[0];
218 char *output_name
= 0;
219 #define bufsize 5000 /* arbitrary size */
224 "Usage: ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]\n";
226 * In previous versions, ansi2knr recognized a --varargs switch.
227 * If this switch was supplied, ansi2knr would attempt to convert
228 * a ... argument to va_alist and va_dcl; if this switch was not
229 * supplied, ansi2knr would simply drop any such arguments.
230 * Now, ansi2knr always does this conversion, and we only
231 * check for this switch for backward compatibility.
233 int convert_varargs
= 1;
236 while ( argc
> 1 && argv
[1][0] == '-' ) {
237 if ( !strcmp(argv
[1], "--varargs") ) {
243 if ( !strcmp(argv
[1], "--filename") && argc
> 2 ) {
249 fprintf(stderr
, "%s: Unrecognized switch: %s\n", program_name
,
251 fprintf(stderr
, usage
);
257 fprintf(stderr
, usage
);
260 output_name
= argv
[2];
261 out
= fopen(output_name
, "w");
263 fprintf(stderr
, "%s: Cannot open output file %s\n",
264 program_name
, output_name
);
269 in
= fopen(argv
[1], "r");
271 fprintf(stderr
, "%s: Cannot open input file %s\n",
272 program_name
, argv
[1]);
282 fprintf(out
, "#line 1 \"%s\"\n", filename
);
283 buf
= malloc(bufsize
);
286 fprintf(stderr
, "Unable to allocate read buffer!\n");
290 while ( fgets(line
, (unsigned)(buf
+ bufsize
- line
), in
) != NULL
)
292 test
: line
+= strlen(line
);
293 switch ( test1(buf
) )
295 case 2: /* a function header */
296 convert1(buf
, out
, 1, convert_varargs
);
298 case 1: /* a function */
299 /* Check for a { at the start of the next line. */
301 f
: if ( line
>= buf
+ (bufsize
- 1) ) /* overflow check */
303 if ( fgets(line
, (unsigned)(buf
+ bufsize
- line
), in
) == NULL
)
305 switch ( *skipspace(ppdirforward(more
), 1) )
308 /* Definitely a function header. */
309 convert1(buf
, out
, 0, convert_varargs
);
313 /* The next line was blank or a comment: */
314 /* keep scanning for a non-comment. */
315 line
+= strlen(line
);
318 /* buf isn't a function header, but */
326 case -1: /* maybe the start of a function */
327 if ( line
!= buf
+ (bufsize
- 1) ) /* overflow check */
330 default: /* not a function */
340 output_error
= ferror(out
);
341 output_error
|= fclose(out
);
342 } else { /* out == stdout */
344 output_error
= ferror(out
);
346 if ( output_error
) {
347 fprintf(stderr
, "%s: error writing to %s\n", program_name
,
348 (output_name
? output_name
: "stdout"));
357 * Skip forward or backward over one or more preprocessor directives.
363 for (; *p
== '#'; ++p
) {
364 for (; *p
!= '\r' && *p
!= '\n'; ++p
)
367 if (*p
== '\r' && p
[1] == '\n')
373 ppdirbackward(p
, limit
)
380 if (*np
== '\n' && np
[-1] == '\r')
382 for (; np
> limit
&& np
[-1] != '\r' && np
[-1] != '\n'; --np
)
391 * Skip over whitespace, comments, and preprocessor directives,
392 * in either direction.
397 int dir
; /* 1 for forward, -1 for backward */
400 while ( is_space(*p
) )
402 if ( !(*p
== '/' && p
[dir
] == '*') )
405 while ( !(*p
== '*' && p
[dir
] == '/') ) {
407 return p
; /* multi-line comment?? */
415 /* Scan over a quoted string, in either direction. */
421 for (p
+= dir
; ; p
+= dir
)
422 if (*p
== '"' && p
[-dir
] != '\\')
427 * Write blanks over part of a string.
428 * Don't overwrite end-of-line characters.
431 writeblanks(start
, end
)
435 for ( p
= start
; p
< end
; p
++ )
436 if ( *p
!= '\r' && *p
!= '\n' )
442 * Test whether the string in buf is a function definition.
443 * The string may contain and/or end with a newline.
445 * 0 - definitely not a function definition;
446 * 1 - definitely a function definition;
447 * 2 - definitely a function prototype (NOT USED);
448 * -1 - may be the beginning of a function definition,
449 * append another line and look again.
450 * The reason we don't attempt to convert function prototypes is that
451 * Ghostscript's declaration-generating macros look too much like
452 * prototypes, and confuse the algorithms.
462 if ( !isidfirstchar(*p
) )
463 return 0; /* no name at left margin */
464 bend
= skipspace(ppdirbackward(buf
+ strlen(buf
) - 1, buf
), -1);
467 case ';': contin
= 0 /*2*/; break;
468 case ')': contin
= 1; break;
469 case '{': return 0; /* not a function */
470 case '}': return 0; /* not a function */
471 default: contin
= -1;
473 while ( isidchar(*p
) )
478 return 0; /* not a function */
481 return 0; /* no parameters */
482 /* Check that the apparent function name isn't a keyword. */
483 /* We only need to check for keywords that could be followed */
484 /* by a left parenthesis (which, unfortunately, is most of them). */
485 { static char *words
[] =
486 { "asm", "auto", "case", "char", "const", "double",
487 "extern", "float", "for", "if", "int", "long",
488 "register", "return", "short", "signed", "sizeof",
489 "static", "switch", "typedef", "unsigned",
490 "void", "volatile", "while", 0
494 unsigned len
= endfn
- buf
;
496 while ( (kp
= *key
) != 0 )
497 { if ( strlen(kp
) == len
&& !strncmp(kp
, buf
, len
) )
498 return 0; /* name is a keyword */
506 * Check for identifier1(identifier2) and not
507 * identifier1(void), or identifier1(identifier2, xxxx).
510 while ( isidchar(*p
) )
515 (*p
== ')' && (len
!= 4 || strncmp(id
, "void", 4)))
517 return 0; /* not a function */
520 * If the last significant character was a ), we need to count
521 * parentheses, because it might be part of a formal parameter
522 * that is a procedure.
527 for (p
= skipspace(buf
, 1); *p
; p
= skipspace(p
+ 1, 1))
528 level
+= (*p
== '(' ? 1 : *p
== ')' ? -1 : 0);
535 /* Convert a recognized function definition or header to K&R syntax. */
537 convert1(buf
, out
, header
, convert_varargs
)
540 int header
; /* Boolean */
541 int convert_varargs
; /* Boolean */
545 * The breaks table contains pointers to the beginning and end
549 unsigned num_breaks
= 2; /* for testing */
555 /* Pre-ANSI implementations don't agree on whether strchr */
556 /* is called strchr or index, so we open-code it here. */
557 for ( endfn
= buf
; *(endfn
++) != '('; )
560 breaks
= (char **)malloc(sizeof(char *) * num_breaks
* 2);
561 if ( breaks
== NULL
)
562 { /* Couldn't allocate break table, give up */
563 fprintf(stderr
, "Unable to allocate break table!\n");
567 btop
= breaks
+ num_breaks
* 2 - 2;
569 /* Parse the argument list */
577 { /* Filled up break table. */
578 /* Allocate a bigger one and start over. */
579 free((char *)breaks
);
584 /* Find the end of the argument */
585 for ( ; end
== NULL
; p
++ )
589 if ( !level
) end
= p
;
592 if ( !level
) lp
= p
;
596 if ( --level
< 0 ) end
= p
;
601 p
= skipspace(p
, 1) - 1;
604 p
= scanstring(p
, 1) - 1;
610 /* Erase any embedded prototype parameters. */
612 writeblanks(lp
+ 1, rp
);
613 p
--; /* back up over terminator */
614 /* Find the name being declared. */
615 /* This is complicated because of procedure and */
616 /* array modifiers. */
618 { p
= skipspace(p
- 1, -1);
621 case ']': /* skip array dimension(s) */
622 case ')': /* skip procedure args OR name */
634 if (p
> buf
&& p
[-1] == '*')
635 p
= skipspace(p
, -1) + 1;
638 p
= scanstring(p
, -1) + 1;
643 if ( *p
== '(' && *skipspace(p
+ 1, 1) == '*' )
644 { /* We found the name being declared */
645 while ( !isidfirstchar(*p
) )
646 p
= skipspace(p
, 1) + 1;
654 found
: if ( *p
== '.' && p
[-1] == '.' && p
[-2] == '.' )
655 { if ( convert_varargs
)
656 { *bp
++ = "va_alist";
661 if ( bp
== breaks
+ 1 ) /* sole argument */
662 writeblanks(breaks
[0], p
);
664 writeblanks(bp
[-1] - 1, p
);
669 { while ( isidchar(*p
) ) p
--;
674 while ( *p
++ == ',' );
676 /* Make a special check for 'void' arglist */
677 if ( bp
== breaks
+2 )
678 { p
= skipspace(breaks
[0], 1);
679 if ( !strncmp(p
, "void", 4) )
680 { p
= skipspace(p
+4, 1);
681 if ( p
== breaks
[2] - 1 )
682 { bp
= breaks
; /* yup, pretend arglist is empty */
683 writeblanks(breaks
[0], p
+ 1);
687 /* Put out the function name and left parenthesis. */
689 while ( p
!= endfn
) putc(*p
, out
), p
++;
690 /* Put out the declaration. */
693 for ( p
= breaks
[0]; *p
; p
++ )
694 if ( *p
== '\r' || *p
== '\n' )
698 { for ( ap
= breaks
+1; ap
< bp
; ap
+= 2 )
700 while ( isidchar(*p
) )
706 /* Put out the argument declarations */
707 for ( ap
= breaks
+2; ap
<= bp
; ap
+= 2 )
711 fputs(breaks
[0], out
); /* any prior args */
712 fputs("va_dcl", out
); /* the final arg */
716 fputs(breaks
[0], out
);
718 free((char *)breaks
);
This page took 0.071829 seconds and 4 git commands to generate.