contrib/ntp/util/ansi2knr.c

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