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