- Weitere Anpassungen an pre-ANSI-Compiler.
[ngircd-alex.git] / src / portab / ansi2knr.c
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 }