ansi2knr.c@ 225

Last change on this file since 225 was 151, checked in by bird, 20 years ago
Initial revision
Property svn:eol-style set to `native`
File size: 19.8 KB

Line
1	/* Copyright (C) 1989, 2000 Aladdin Enterprises. All rights reserved. */
2
3	/$Id: ansi2knr.c,v 1.3 2000/04/13 03:41:48 lpd Exp $/
4	/* Convert ANSI C function definitions to K&R ("traditional C") syntax */
5
6	/*
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.
12
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
19	copies.
20
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.
28	*/
29
30	/*
31	* Usage:
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.
38	*
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
44	* consisting of only
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.
58	*/
59
60	/*
61	* The original and principal author of ansi2knr is L. Peter Deutsch
62	* <[email protected]>. Other authors are noted in the change history
63	* that follows (in reverse chronological order):
64
65	lpd 2000-04-12 backs out Eggert's changes because of bugs:
66	- concatlits didn't declare the type of its bufend argument;
67	- concatlits didn't recognize when it was inside a comment;
68	- scanstring could scan backward past the beginning of the string; when
69	- the check for \ + newline in scanstring was unnecessary.
70
71	2000-03-05 Paul Eggert <[email protected]>
72
73	Add support for concatenated string literals.
74	* ansi2knr.c (concatlits): New decl.
75	(main): Invoke concatlits to concatenate string literals.
76	(scanstring): Handle backslash-newline correctly. Work with
77	character constants. Fix bug when scanning backwards through
78	backslash-quote. Check for unterminated strings.
79	(convert1): Parse character constants, too.
80	(appendline, concatlits): New functions.
81	* ansi2knr.1: Document this.
82
83	lpd 1999-08-17 added code to allow preprocessor directives
84	wherever comments are allowed
85	lpd 1999-04-12 added minor fixes from Pavel Roskin
86	<[email protected]> for clean compilation with
87	gcc -W -Wall
88	lpd 1999-03-22 added hack to recognize lines consisting of
89	identifier1(identifier2, xxx) as not being procedures
90	lpd 1999-02-03 made indentation of preprocessor commands consistent
91	lpd 1999-01-28 fixed two bugs: a '/' in an argument list caused an
92	endless loop; quoted strings within an argument list
93	confused the parser
94	lpd 1999-01-24 added a check for write errors on the output,
95	suggested by Jim Meyering <[email protected]>
96	lpd 1998-11-09 added further hack to recognize identifier(void)
97	as being a procedure
98	lpd 1998-10-23 added hack to recognize lines consisting of
99	identifier1(identifier2) as not being procedures
100	lpd 1997-12-08 made input_file optional; only closes input and/or
101	output file if not stdin or stdout respectively; prints
102	usage message on stderr rather than stdout; adds
103	--filename switch (changes suggested by
104	<[email protected]>)
105	lpd 1996-01-21 added code to cope with not HAVE_CONFIG_H and with
106	compilers that don't understand void, as suggested by
107	Tom Lane
108	lpd 1996-01-15 changed to require that the first non-comment token
109	on the line following a function header be a left brace,
110	to reduce sensitivity to macros, as suggested by Tom Lane
111	<[email protected]>
112	lpd 1995-06-22 removed #ifndefs whose sole purpose was to define
113	undefined preprocessor symbols as 0; changed all #ifdefs
114	for configuration symbols to #ifs
115	lpd 1995-04-05 changed copyright notice to make it clear that
116	including ansi2knr in a program does not bring the entire
117	program under the GPL
118	lpd 1994-12-18 added conditionals for systems where ctype macros
119	don't handle 8-bit characters properly, suggested by
120	Francois Pinard <[email protected]>;
121	removed --varargs switch (this is now the default)
122	lpd 1994-10-10 removed CONFIG_BROKETS conditional
123	lpd 1994-07-16 added some conditionals to help GNU `configure',
124	suggested by Francois Pinard <[email protected]>;
125	properly erase prototype args in function parameters,
126	contributed by Jim Avera <[email protected]>;
127	correct error in writeblanks (it shouldn't erase EOLs)
128	lpd 1989-xx-xx original version
129	*/
130
131	/* Most of the conditionals here are to make ansi2knr work with */
132	/* or without the GNU configure machinery. */
133
134	#if HAVE_CONFIG_H
135	# include <config.h>
136	#endif
137
138	#include <stdio.h>
139	#include <ctype.h>
140
141	#if HAVE_CONFIG_H
142
143	/*
144	For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
145	This will define HAVE_CONFIG_H and so, activate the following lines.
146	*/
147
148	# if STDC_HEADERS \|\| HAVE_STRING_H
149	# include <string.h>
150	# else
151	# include <strings.h>
152	# endif
153
154	#else /* not HAVE_CONFIG_H */
155
156	/* Otherwise do it the hard way */
157
158	# ifdef BSD
159	# include <strings.h>
160	# else
161	# ifdef VMS
162	extern int strlen(), strncmp();
163	# else
164	# include <string.h>
165	# endif
166	# endif
167
168	#endif /* not HAVE_CONFIG_H */
169
170	#if STDC_HEADERS
171	# include <stdlib.h>
172	#else
173	/*
174	malloc and free should be declared in stdlib.h,
175	but if you've got a K&R compiler, they probably aren't.
176	*/
177	# ifdef MSDOS
178	# include <malloc.h>
179	# else
180	# ifdef VMS
181	extern char *malloc();
182	extern void free();
183	# else
184	extern char *malloc();
185	extern int free();
186	# endif
187	# endif
188
189	#endif
190
191	/* Define NULL (for very old compilers). */
192	#ifndef NULL
193	# define NULL (0)
194	#endif
195
196	/*
197	* The ctype macros don't always handle 8-bit characters correctly.
198	* Compensate for this here.
199	*/
200	#ifdef isascii
201	# undef HAVE_ISASCII /* just in case */
202	# define HAVE_ISASCII 1
203	#else
204	#endif
205	#if STDC_HEADERS \|\| !HAVE_ISASCII
206	# define is_ascii(c) 1
207	#else
208	# define is_ascii(c) isascii(c)
209	#endif
210
211	#define is_space(c) (is_ascii(c) && isspace(c))
212	#define is_alpha(c) (is_ascii(c) && isalpha(c))
213	#define is_alnum(c) (is_ascii(c) && isalnum(c))
214
215	/* Scanning macros */
216	#define isidchar(ch) (is_alnum(ch) \|\| (ch) == '_')
217	#define isidfirstchar(ch) (is_alpha(ch) \|\| (ch) == '_')
218
219	/* Forward references */
220	char *ppdirforward();
221	char *ppdirbackward();
222	char *skipspace();
223	char *scanstring();
224	int writeblanks();
225	int test1();
226	int convert1();
227
228	/* The main program */
229	int
230	main(argc, argv)
231	int argc;
232	char *argv[];
233	{ FILE *in = stdin;
234	FILE *out = stdout;
235	char *filename = 0;
236	char *program_name = argv[0];
237	char *output_name = 0;
238	#define bufsize 5000 /* arbitrary size */
239	char *buf;
240	char *line;
241	char *more;
242	char *usage =
243	"Usage: ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]\n";
244	/*
245	* In previous versions, ansi2knr recognized a --varargs switch.
246	* If this switch was supplied, ansi2knr would attempt to convert
247	* a ... argument to va_alist and va_dcl; if this switch was not
248	* supplied, ansi2knr would simply drop any such arguments.
249	* Now, ansi2knr always does this conversion, and we only
250	* check for this switch for backward compatibility.
251	*/
252	int convert_varargs = 1;
253	int output_error;
254
255	while ( argc > 1 && argv[1][0] == '-' ) {
256	if ( !strcmp(argv[1], "--varargs") ) {
257	convert_varargs = 1;
258	argc--;
259	argv++;
260	continue;
261	}
262	if ( !strcmp(argv[1], "--filename") && argc > 2 ) {
263	filename = argv[2];
264	argc -= 2;
265	argv += 2;
266	continue;
267	}
268	fprintf(stderr, "%s: Unrecognized switch: %s\n", program_name,
269	argv[1]);
270	fprintf(stderr, usage);
271	exit(1);
272	}
273	switch ( argc )
274	{
275	default:
276	fprintf(stderr, usage);
277	exit(0);
278	case 3:
279	output_name = argv[2];
280	out = fopen(output_name, "w");
281	if ( out == NULL ) {
282	fprintf(stderr, "%s: Cannot open output file %s\n",
283	program_name, output_name);
284	exit(1);
285	}
286	/* falls through */
287	case 2:
288	in = fopen(argv[1], "r");
289	if ( in == NULL ) {
290	fprintf(stderr, "%s: Cannot open input file %s\n",
291	program_name, argv[1]);
292	exit(1);
293	}
294	if ( filename == 0 )
295	filename = argv[1];
296	/* falls through */
297	case 1:
298	break;
299	}
300	if ( filename )
301	fprintf(out, "#line 1 \"%s\"\n", filename);
302	buf = malloc(bufsize);
303	if ( buf == NULL )
304	{
305	fprintf(stderr, "Unable to allocate read buffer!\n");
306	exit(1);
307	}
308	line = buf;
309	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
310	{
311	test: line += strlen(line);
312	switch ( test1(buf) )
313	{
314	case 2: /* a function header */
315	convert1(buf, out, 1, convert_varargs);
316	break;
317	case 1: /* a function */
318	/* Check for a { at the start of the next line. */
319	more = ++line;
320	f: if ( line >= buf + (bufsize - 1) ) /* overflow check */
321	goto wl;
322	if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
323	goto wl;
324	switch ( *skipspace(ppdirforward(more), 1) )
325	{
326	case '{':
327	/* Definitely a function header. */
328	convert1(buf, out, 0, convert_varargs);
329	fputs(more, out);
330	break;
331	case 0:
332	/* The next line was blank or a comment: */
333	/* keep scanning for a non-comment. */
334	line += strlen(line);
335	goto f;
336	default:
337	/* buf isn't a function header, but */
338	/* more might be. */
339	fputs(buf, out);
340	strcpy(buf, more);
341	line = buf;
342	goto test;
343	}
344	break;
345	case -1: /* maybe the start of a function */
346	if ( line != buf + (bufsize - 1) ) /* overflow check */
347	continue;
348	/* falls through */
349	default: /* not a function */
350	wl: fputs(buf, out);
351	break;
352	}
353	line = buf;
354	}
355	if ( line != buf )
356	fputs(buf, out);
357	free(buf);
358	if ( output_name ) {
359	output_error = ferror(out);
360	output_error \|= fclose(out);
361	} else { /* out == stdout */
362	fflush(out);
363	output_error = ferror(out);
364	}
365	if ( output_error ) {
366	fprintf(stderr, "%s: error writing to %s\n", program_name,
367	(output_name ? output_name : "stdout"));
368	exit(1);
369	}
370	if ( in != stdin )
371	fclose(in);
372	return 0;
373	}
374
375	/*
376	* Skip forward or backward over one or more preprocessor directives.
377	*/
378	char *
379	ppdirforward(p)
380	char *p;
381	{
382	for (; *p == '#'; ++p) {
383	for (; p != '\r' && p != '\n'; ++p)
384	if (*p == 0)
385	return p;
386	if (*p == '\r' && p[1] == '\n')
387	++p;
388	}
389	return p;
390	}
391	char *
392	ppdirbackward(p, limit)
393	char *p;
394	char *limit;
395	{
396	char *np = p;
397
398	for (;; p = --np) {
399	if (*np == '\n' && np[-1] == '\r')
400	--np;
401	for (; np > limit && np[-1] != '\r' && np[-1] != '\n'; --np)
402	if (np[-1] == 0)
403	return np;
404	if (*np != '#')
405	return p;
406	}
407	}
408
409	/*
410	* Skip over whitespace, comments, and preprocessor directives,
411	* in either direction.
412	*/
413	char *
414	skipspace(p, dir)
415	char *p;
416	int dir; /* 1 for forward, -1 for backward */
417	{
418	for ( ; ; ) {
419	while ( is_space(*p) )
420	p += dir;
421	if ( !(p == '/' && p[dir] == '') )
422	break;
423	p += dir; p += dir;
424	while ( !(p == '' && p[dir] == '/') ) {
425	if ( *p == 0 )
426	return p; /* multi-line comment?? */
427	p += dir;
428	}
429	p += dir; p += dir;
430	}
431	return p;
432	}
433
434	/* Scan over a quoted string, in either direction. */
435	char *
436	scanstring(p, dir)
437	char *p;
438	int dir;
439	{
440	for (p += dir; ; p += dir)
441	if (*p == '"' && p[-dir] != '\\')
442	return p + dir;
443	}
444
445	/*
446	* Write blanks over part of a string.
447	* Don't overwrite end-of-line characters.
448	*/
449	int
450	writeblanks(start, end)
451	char *start;
452	char *end;
453	{ char *p;
454	for ( p = start; p < end; p++ )
455	if ( p != '\r' && p != '\n' )
456	*p = ' ';
457	return 0;
458	}
459
460	/*
461	* Test whether the string in buf is a function definition.
462	* The string may contain and/or end with a newline.
463	* Return as follows:
464	* 0 - definitely not a function definition;
465	* 1 - definitely a function definition;
466	* 2 - definitely a function prototype (NOT USED);
467	* -1 - may be the beginning of a function definition,
468	* append another line and look again.
469	* The reason we don't attempt to convert function prototypes is that
470	* Ghostscript's declaration-generating macros look too much like
471	* prototypes, and confuse the algorithms.
472	*/
473	int
474	test1(buf)
475	char *buf;
476	{ char *p = buf;
477	char *bend;
478	char *endfn;
479	int contin;
480
481	if ( !isidfirstchar(*p) )
482	return 0; /* no name at left margin */
483	bend = skipspace(ppdirbackward(buf + strlen(buf) - 1, buf), -1);
484	switch ( *bend )
485	{
486	case ';': contin = 0 /2/; break;
487	case ')': contin = 1; break;
488	case '{': return 0; /* not a function */
489	case '}': return 0; /* not a function */
490	default: contin = -1;
491	}
492	while ( isidchar(*p) )
493	p++;
494	endfn = p;
495	p = skipspace(p, 1);
496	if ( *p++ != '(' )
497	return 0; /* not a function */
498	p = skipspace(p, 1);
499	if ( *p == ')' )
500	return 0; /* no parameters */
501	/* Check that the apparent function name isn't a keyword. */
502	/* We only need to check for keywords that could be followed */
503	/* by a left parenthesis (which, unfortunately, is most of them). */
504	{ static char *words[] =
505	{ "asm", "auto", "case", "char", "const", "double",
506	"extern", "float", "for", "if", "int", "long",
507	"register", "return", "short", "signed", "sizeof",
508	"static", "switch", "typedef", "unsigned",
509	"void", "volatile", "while", 0
510	};
511	char **key = words;
512	char *kp;
513	unsigned len = endfn - buf;
514
515	while ( (kp = *key) != 0 )
516	{ if ( strlen(kp) == len && !strncmp(kp, buf, len) )
517	return 0; /* name is a keyword */
518	key++;
519	}
520	}
521	{
522	char *id = p;
523	int len;
524	/*
525	* Check for identifier1(identifier2) and not
526	* identifier1(void), or identifier1(identifier2, xxxx).
527	*/
528
529	while ( isidchar(*p) )
530	p++;
531	len = p - id;
532	p = skipspace(p, 1);
533	if (*p == ',' \|\|
534	(*p == ')' && (len != 4 \|\| strncmp(id, "void", 4)))
535	)
536	return 0; /* not a function */
537	}
538	/*
539	* If the last significant character was a ), we need to count
540	* parentheses, because it might be part of a formal parameter
541	* that is a procedure.
542	*/
543	if (contin > 0) {
544	int level = 0;
545
546	for (p = skipspace(buf, 1); *p; p = skipspace(p + 1, 1))
547	level += (p == '(' ? 1 : p == ')' ? -1 : 0);
548	if (level > 0)
549	contin = -1;
550	}
551	return contin;
552	}
553
554	/* Convert a recognized function definition or header to K&R syntax. */
555	int
556	convert1(buf, out, header, convert_varargs)
557	char *buf;
558	FILE *out;
559	int header; /* Boolean */
560	int convert_varargs; /* Boolean */
561	{ char *endfn;
562	char *p;
563	/*
564	* The breaks table contains pointers to the beginning and end
565	* of each argument.
566	*/
567	char **breaks;
568	unsigned num_breaks = 2; /* for testing */
569	char **btop;
570	char **bp;
571	char **ap;
572	char *vararg = 0;
573
574	/* Pre-ANSI implementations don't agree on whether strchr */
575	/* is called strchr or index, so we open-code it here. */
576	for ( endfn = buf; *(endfn++) != '('; )
577	;
578	top: p = endfn;
579	breaks = (char *)malloc(sizeof(char ) * num_breaks * 2);
580	if ( breaks == NULL )
581	{ /* Couldn't allocate break table, give up */
582	fprintf(stderr, "Unable to allocate break table!\n");
583	fputs(buf, out);
584	return -1;
585	}
586	btop = breaks + num_breaks * 2 - 2;
587	bp = breaks;
588	/* Parse the argument list */
589	do
590	{ int level = 0;
591	char *lp = NULL;
592	char *rp = NULL;
593	char *end = NULL;
594
595	if ( bp >= btop )
596	{ /* Filled up break table. */
597	/* Allocate a bigger one and start over. */
598	free((char *)breaks);
599	num_breaks <<= 1;
600	goto top;
601	}
602	*bp++ = p;
603	/* Find the end of the argument */
604	for ( ; end == NULL; p++ )
605	{ switch(*p)
606	{
607	case ',':
608	if ( !level ) end = p;
609	break;
610	case '(':
611	if ( !level ) lp = p;
612	level++;
613	break;
614	case ')':
615	if ( --level < 0 ) end = p;
616	else rp = p;
617	break;
618	case '/':
619	if (p[1] == '*')
620	p = skipspace(p, 1) - 1;
621	break;
622	case '"':
623	p = scanstring(p, 1) - 1;
624	break;
625	default:
626	;
627	}
628	}
629	/* Erase any embedded prototype parameters. */
630	if ( lp && rp )
631	writeblanks(lp + 1, rp);
632	p--; /* back up over terminator */
633	/* Find the name being declared. */
634	/* This is complicated because of procedure and */
635	/* array modifiers. */
636	for ( ; ; )
637	{ p = skipspace(p - 1, -1);
638	switch ( *p )
639	{
640	case ']': /* skip array dimension(s) */
641	case ')': /* skip procedure args OR name */
642	{ int level = 1;
643	while ( level )
644	switch ( *--p )
645	{
646	case ']': case ')':
647	level++;
648	break;
649	case '[': case '(':
650	level--;
651	break;
652	case '/':
653	if (p > buf && p[-1] == '*')
654	p = skipspace(p, -1) + 1;
655	break;
656	case '"':
657	p = scanstring(p, -1) + 1;
658	break;
659	default: ;
660	}
661	}
662	if ( p == '(' && skipspace(p + 1, 1) == '*' )
663	{ /* We found the name being declared */
664	while ( !isidfirstchar(*p) )
665	p = skipspace(p, 1) + 1;
666	goto found;
667	}
668	break;
669	default:
670	goto found;
671	}
672	}
673	found: if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
674	{ if ( convert_varargs )
675	{ *bp++ = "va_alist";
676	vararg = p-2;
677	}
678	else
679	{ p++;
680	if ( bp == breaks + 1 ) /* sole argument */
681	writeblanks(breaks[0], p);
682	else
683	writeblanks(bp[-1] - 1, p);
684	bp--;
685	}
686	}
687	else
688	{ while ( isidchar(*p) ) p--;
689	*bp++ = p+1;
690	}
691	p = end;
692	}
693	while ( *p++ == ',' );
694	*bp = p;
695	/* Make a special check for 'void' arglist */
696	if ( bp == breaks+2 )
697	{ p = skipspace(breaks[0], 1);
698	if ( !strncmp(p, "void", 4) )
699	{ p = skipspace(p+4, 1);
700	if ( p == breaks[2] - 1 )
701	{ bp = breaks; /* yup, pretend arglist is empty */
702	writeblanks(breaks[0], p + 1);
703	}
704	}
705	}
706	/* Put out the function name and left parenthesis. */
707	p = buf;
708	while ( p != endfn ) putc(*p, out), p++;
709	/* Put out the declaration. */
710	if ( header )
711	{ fputs(");", out);
712	for ( p = breaks[0]; *p; p++ )
713	if ( p == '\r' \|\| p == '\n' )
714	putc(*p, out);
715	}
716	else
717	{ for ( ap = breaks+1; ap < bp; ap += 2 )
718	{ p = *ap;
719	while ( isidchar(*p) )
720	putc(*p, out), p++;
721	if ( ap < bp - 1 )
722	fputs(", ", out);
723	}
724	fputs(") ", out);
725	/* Put out the argument declarations */
726	for ( ap = breaks+2; ap <= bp; ap += 2 )
727	(*ap)[-1] = ';';
728	if ( vararg != 0 )
729	{ *vararg = 0;
730	fputs(breaks[0], out); /* any prior args */
731	fputs("va_dcl", out); /* the final arg */
732	fputs(bp[0], out);
733	}
734	else
735	fputs(breaks[0], out);
736	}
737	free((char *)breaks);
738	return 0;
739	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/gmake/ansi2knr.c@ 225

Download in other formats: