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