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 }