Annotation of embedaddon/lrzsz/src/ansi2knr.c, revision 1.1
1.1 ! misho 1: /* Copyright (C) 1989, 1997 Aladdin Enterprises. All rights reserved. */
! 2:
! 3: /* hacked up by uo to get around automake-1.3-problem */
! 4:
! 5: /*$Id: ansi2knr.c,v 1.5 1998/12/27 16:09:19 uwe Exp $*/
! 6: /* Convert ANSI C function definitions to K&R ("traditional C") syntax */
! 7:
! 8: /*
! 9: ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
! 10: WARRANTY. No author or distributor accepts responsibility to anyone for the
! 11: consequences of using it or for whether it serves any particular purpose or
! 12: works at all, unless he says so in writing. Refer to the GNU General Public
! 13: License (the "GPL") for full details.
! 14:
! 15: Everyone is granted permission to copy, modify and redistribute ansi2knr,
! 16: but only under the conditions described in the GPL. A copy of this license
! 17: is supposed to have been given to you along with ansi2knr so you can know
! 18: your rights and responsibilities. It should be in a file named COPYLEFT,
! 19: or, if there is no file named COPYLEFT, a file named COPYING. Among other
! 20: things, the copyright notice and this notice must be preserved on all
! 21: copies.
! 22:
! 23: We explicitly state here what we believe is already implied by the GPL: if
! 24: the ansi2knr program is distributed as a separate set of sources and a
! 25: separate executable file which are aggregated on a storage medium together
! 26: with another program, this in itself does not bring the other program under
! 27: the GPL, nor does the mere fact that such a program or the procedures for
! 28: constructing it invoke the ansi2knr executable bring any other part of the
! 29: program under the GPL.
! 30: */
! 31:
! 32: /*
! 33: * ----- not valid at the moment -- uwe ------
! 34: * Usage:
! 35: ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]
! 36: * --filename provides the file name for the #line directive in the output,
! 37: * overriding input_file (if present).
! 38: * If no input_file is supplied, input is read from stdin.
! 39: * If no output_file is supplied, output goes to stdout.
! 40: * There are no error messages.
! 41: *
! 42: * ansi2knr recognizes function definitions by seeing a non-keyword
! 43: * identifier at the left margin, followed by a left parenthesis,
! 44: * with a right parenthesis as the last character on the line,
! 45: * and with a left brace as the first token on the following line
! 46: * (ignoring possible intervening comments).
! 47: * It will recognize a multi-line header provided that no intervening
! 48: * line ends with a left or right brace or a semicolon.
! 49: * These algorithms ignore whitespace and comments, except that
! 50: * the function name must be the first thing on the line.
! 51: * The following constructs will confuse it:
! 52: * - Any other construct that starts at the left margin and
! 53: * follows the above syntax (such as a macro or function call).
! 54: * - Some macros that tinker with the syntax of the function header.
! 55: */
! 56:
! 57: /*
! 58: * The original and principal author of ansi2knr is L. Peter Deutsch
! 59: * <ghost@aladdin.com>. Other authors are noted in the change history
! 60: * that follows (in reverse chronological order):
! 61: lpd 97-12-08 made input_file optional; only closes input and/or
! 62: output file if not stdin or stdout respectively; prints
! 63: usage message on stderr rather than stdout; adds
! 64: --filename switch (changes suggested by
! 65: <ceder@lysator.liu.se>)
! 66: lpd 96-01-21 added code to cope with not HAVE_CONFIG_H and with
! 67: compilers that don't understand void, as suggested by
! 68: Tom Lane
! 69: lpd 96-01-15 changed to require that the first non-comment token
! 70: on the line following a function header be a left brace,
! 71: to reduce sensitivity to macros, as suggested by Tom Lane
! 72: <tgl@sss.pgh.pa.us>
! 73: lpd 95-06-22 removed #ifndefs whose sole purpose was to define
! 74: undefined preprocessor symbols as 0; changed all #ifdefs
! 75: for configuration symbols to #ifs
! 76: lpd 95-04-05 changed copyright notice to make it clear that
! 77: including ansi2knr in a program does not bring the entire
! 78: program under the GPL
! 79: lpd 94-12-18 added conditionals for systems where ctype macros
! 80: don't handle 8-bit characters properly, suggested by
! 81: Francois Pinard <pinard@iro.umontreal.ca>;
! 82: removed --varargs switch (this is now the default)
! 83: lpd 94-10-10 removed CONFIG_BROKETS conditional
! 84: lpd 94-07-16 added some conditionals to help GNU `configure',
! 85: suggested by Francois Pinard <pinard@iro.umontreal.ca>;
! 86: properly erase prototype args in function parameters,
! 87: contributed by Jim Avera <jima@netcom.com>;
! 88: correct error in writeblanks (it shouldn't erase EOLs)
! 89: lpd 89-xx-xx original version
! 90: */
! 91:
! 92: /* Most of the conditionals here are to make ansi2knr work with */
! 93: /* or without the GNU configure machinery. */
! 94:
! 95: #if HAVE_CONFIG_H
! 96: # include <config.h>
! 97: #endif
! 98:
! 99: #include <stdio.h>
! 100: #include <ctype.h>
! 101:
! 102: #if HAVE_CONFIG_H
! 103:
! 104: /*
! 105: For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
! 106: This will define HAVE_CONFIG_H and so, activate the following lines.
! 107: */
! 108:
! 109: # if STDC_HEADERS || HAVE_STRING_H
! 110: # include <string.h>
! 111: # else
! 112: # include <strings.h>
! 113: # endif
! 114:
! 115: #else /* not HAVE_CONFIG_H */
! 116:
! 117: /* Otherwise do it the hard way */
! 118:
! 119: # ifdef BSD
! 120: # include <strings.h>
! 121: # else
! 122: # ifdef VMS
! 123: extern int strlen(), strncmp();
! 124: # else
! 125: # include <string.h>
! 126: # endif
! 127: # endif
! 128:
! 129: #endif /* not HAVE_CONFIG_H */
! 130:
! 131: #if STDC_HEADERS
! 132: # include <stdlib.h>
! 133: #else
! 134: /*
! 135: malloc and free should be declared in stdlib.h,
! 136: but if you've got a K&R compiler, they probably aren't.
! 137: */
! 138: # ifdef MSDOS
! 139: # include <malloc.h>
! 140: # else
! 141: # ifdef VMS
! 142: extern char *malloc();
! 143: extern void free();
! 144: # else
! 145: extern char *malloc();
! 146: extern int free();
! 147: # endif
! 148: # endif
! 149:
! 150: #endif
! 151:
! 152: /*
! 153: * The ctype macros don't always handle 8-bit characters correctly.
! 154: * Compensate for this here.
! 155: */
! 156: #ifdef isascii
! 157: # undef HAVE_ISASCII /* just in case */
! 158: # define HAVE_ISASCII 1
! 159: #else
! 160: #endif
! 161: #if STDC_HEADERS || !HAVE_ISASCII
! 162: # define is_ascii(c) 1
! 163: #else
! 164: # define is_ascii(c) isascii(c)
! 165: #endif
! 166:
! 167: #define is_space(c) (is_ascii(c) && isspace(c))
! 168: #define is_alpha(c) (is_ascii(c) && isalpha(c))
! 169: #define is_alnum(c) (is_ascii(c) && isalnum(c))
! 170:
! 171: /* Scanning macros */
! 172: #define isidchar(ch) (is_alnum(ch) || (ch) == '_')
! 173: #define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')
! 174:
! 175: /* Forward references */
! 176: char *skipspace();
! 177: int writeblanks();
! 178: int test1();
! 179: int convert1();
! 180:
! 181: /* The main program */
! 182: int
! 183: main(argc, argv)
! 184: int argc;
! 185: char *argv[];
! 186: { FILE *in = stdin;
! 187: FILE *out = stdout;
! 188: char *filename = 0;
! 189: #define bufsize 5000 /* arbitrary size */
! 190: char *buf;
! 191: char *line;
! 192: char *more;
! 193: char *usage =
! 194: "Usage: ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]\n";
! 195: /*
! 196: * In previous versions, ansi2knr recognized a --varargs switch.
! 197: * If this switch was supplied, ansi2knr would attempt to convert
! 198: * a ... argument to va_alist and va_dcl; if this switch was not
! 199: * supplied, ansi2knr would simply drop any such arguments.
! 200: * Now, ansi2knr always does this conversion, and we only
! 201: * check for this switch for backward compatibility.
! 202: */
! 203: int convert_varargs = 0;
! 204:
! 205: while ( argc > 1 && argv[1][0] == '-' ) {
! 206: if ( !strcmp(argv[1], "--varargs") ) {
! 207: convert_varargs = 1;
! 208: argc--;
! 209: argv++;
! 210: continue;
! 211: }
! 212: if ( !strcmp(argv[1], "--filename") && argc > 2 ) {
! 213: filename = argv[2];
! 214: argc -= 2;
! 215: argv += 2;
! 216: continue;
! 217: }
! 218: fprintf(stderr, "Unrecognized switch: %s\n", argv[1]);
! 219: fprintf(stderr, usage);
! 220: exit(1);
! 221: }
! 222: switch ( argc )
! 223: {
! 224: default:
! 225: fprintf(stderr, usage);
! 226: exit(0);
! 227: case 2:
! 228: out = fopen(argv[1], "w");
! 229: if ( out == NULL ) {
! 230: fprintf(stderr, "Cannot open output file %s\n", argv[2]);
! 231: exit(1);
! 232: }
! 233: /* falls through */
! 234: case 1:
! 235: break;
! 236: }
! 237: if ( filename )
! 238: fprintf(out, "#line 1 \"%s\"\n", filename);
! 239: buf = malloc(bufsize);
! 240: line = buf;
! 241: while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
! 242: {
! 243: test: line += strlen(line);
! 244: switch ( test1(buf) )
! 245: {
! 246: case 2: /* a function header */
! 247: convert1(buf, out, 1, convert_varargs);
! 248: break;
! 249: case 1: /* a function */
! 250: /* Check for a { at the start of the next line. */
! 251: more = ++line;
! 252: f: if ( line >= buf + (bufsize - 1) ) /* overflow check */
! 253: goto wl;
! 254: if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
! 255: goto wl;
! 256: switch ( *skipspace(more, 1) )
! 257: {
! 258: case '{':
! 259: /* Definitely a function header. */
! 260: convert1(buf, out, 0, convert_varargs);
! 261: fputs(more, out);
! 262: break;
! 263: case 0:
! 264: /* The next line was blank or a comment: */
! 265: /* keep scanning for a non-comment. */
! 266: line += strlen(line);
! 267: goto f;
! 268: default:
! 269: /* buf isn't a function header, but */
! 270: /* more might be. */
! 271: fputs(buf, out);
! 272: strcpy(buf, more);
! 273: line = buf;
! 274: goto test;
! 275: }
! 276: break;
! 277: case -1: /* maybe the start of a function */
! 278: if ( line != buf + (bufsize - 1) ) /* overflow check */
! 279: continue;
! 280: /* falls through */
! 281: default: /* not a function */
! 282: wl: fputs(buf, out);
! 283: break;
! 284: }
! 285: line = buf;
! 286: }
! 287: if ( line != buf )
! 288: fputs(buf, out);
! 289: free(buf);
! 290: if ( out != stdout )
! 291: fclose(out);
! 292: if ( in != stdin )
! 293: fclose(in);
! 294: return 0;
! 295: }
! 296:
! 297: /* Skip over space and comments, in either direction. */
! 298: char *
! 299: skipspace(p, dir)
! 300: register char *p;
! 301: register int dir; /* 1 for forward, -1 for backward */
! 302: { for ( ; ; )
! 303: { while ( is_space(*p) )
! 304: p += dir;
! 305: if ( !(*p == '/' && p[dir] == '*') )
! 306: break;
! 307: p += dir; p += dir;
! 308: while ( !(*p == '*' && p[dir] == '/') )
! 309: { if ( *p == 0 )
! 310: return p; /* multi-line comment?? */
! 311: p += dir;
! 312: }
! 313: p += dir; p += dir;
! 314: }
! 315: return p;
! 316: }
! 317:
! 318: /*
! 319: * Write blanks over part of a string.
! 320: * Don't overwrite end-of-line characters.
! 321: */
! 322: int
! 323: writeblanks(start, end)
! 324: char *start;
! 325: char *end;
! 326: { char *p;
! 327: for ( p = start; p < end; p++ )
! 328: if ( *p != '\r' && *p != '\n' )
! 329: *p = ' ';
! 330: return 0;
! 331: }
! 332:
! 333: /*
! 334: * Test whether the string in buf is a function definition.
! 335: * The string may contain and/or end with a newline.
! 336: * Return as follows:
! 337: * 0 - definitely not a function definition;
! 338: * 1 - definitely a function definition;
! 339: * 2 - definitely a function prototype (NOT USED);
! 340: * -1 - may be the beginning of a function definition,
! 341: * append another line and look again.
! 342: * The reason we don't attempt to convert function prototypes is that
! 343: * Ghostscript's declaration-generating macros look too much like
! 344: * prototypes, and confuse the algorithms.
! 345: */
! 346: int
! 347: test1(buf)
! 348: char *buf;
! 349: { register char *p = buf;
! 350: char *bend;
! 351: char *endfn;
! 352: int contin;
! 353:
! 354: if ( !isidfirstchar(*p) )
! 355: return 0; /* no name at left margin */
! 356: bend = skipspace(buf + strlen(buf) - 1, -1);
! 357: switch ( *bend )
! 358: {
! 359: case ';': contin = 0 /*2*/; break;
! 360: case ')': contin = 1; break;
! 361: case '{': return 0; /* not a function */
! 362: case '}': return 0; /* not a function */
! 363: default: contin = -1;
! 364: }
! 365: while ( isidchar(*p) )
! 366: p++;
! 367: endfn = p;
! 368: p = skipspace(p, 1);
! 369: if ( *p++ != '(' )
! 370: return 0; /* not a function */
! 371: p = skipspace(p, 1);
! 372: if ( *p == ')' )
! 373: return 0; /* no parameters */
! 374: /* Check that the apparent function name isn't a keyword. */
! 375: /* We only need to check for keywords that could be followed */
! 376: /* by a left parenthesis (which, unfortunately, is most of them). */
! 377: { static char *words[] =
! 378: { "asm", "auto", "case", "char", "const", "double",
! 379: "extern", "float", "for", "if", "int", "long",
! 380: "register", "return", "short", "signed", "sizeof",
! 381: "static", "switch", "typedef", "unsigned",
! 382: "void", "volatile", "while", 0
! 383: };
! 384: char **key = words;
! 385: char *kp;
! 386: int len = endfn - buf;
! 387:
! 388: while ( (kp = *key) != 0 )
! 389: { if ( strlen(kp) == len && !strncmp(kp, buf, len) )
! 390: return 0; /* name is a keyword */
! 391: key++;
! 392: }
! 393: }
! 394: return contin;
! 395: }
! 396:
! 397: /* Convert a recognized function definition or header to K&R syntax. */
! 398: int
! 399: convert1(buf, out, header, convert_varargs)
! 400: char *buf;
! 401: FILE *out;
! 402: int header; /* Boolean */
! 403: int convert_varargs; /* Boolean */
! 404: { char *endfn;
! 405: register char *p;
! 406: /*
! 407: * The breaks table contains pointers to the beginning and end
! 408: * of each argument.
! 409: */
! 410: char **breaks;
! 411: unsigned num_breaks = 2; /* for testing */
! 412: char **btop;
! 413: char **bp;
! 414: char **ap;
! 415: char *vararg = 0;
! 416:
! 417: /* Pre-ANSI implementations don't agree on whether strchr */
! 418: /* is called strchr or index, so we open-code it here. */
! 419: for ( endfn = buf; *(endfn++) != '('; )
! 420: ;
! 421: top: p = endfn;
! 422: breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
! 423: if ( breaks == 0 )
! 424: { /* Couldn't allocate break table, give up */
! 425: fprintf(stderr, "Unable to allocate break table!\n");
! 426: fputs(buf, out);
! 427: return -1;
! 428: }
! 429: btop = breaks + num_breaks * 2 - 2;
! 430: bp = breaks;
! 431: /* Parse the argument list */
! 432: do
! 433: { int level = 0;
! 434: char *lp = NULL;
! 435: char *rp;
! 436: char *end = NULL;
! 437:
! 438: if ( bp >= btop )
! 439: { /* Filled up break table. */
! 440: /* Allocate a bigger one and start over. */
! 441: free((char *)breaks);
! 442: num_breaks <<= 1;
! 443: goto top;
! 444: }
! 445: *bp++ = p;
! 446: /* Find the end of the argument */
! 447: for ( ; end == NULL; p++ )
! 448: { switch(*p)
! 449: {
! 450: case ',':
! 451: if ( !level ) end = p;
! 452: break;
! 453: case '(':
! 454: if ( !level ) lp = p;
! 455: level++;
! 456: break;
! 457: case ')':
! 458: if ( --level < 0 ) end = p;
! 459: else rp = p;
! 460: break;
! 461: case '/':
! 462: p = skipspace(p, 1) - 1;
! 463: break;
! 464: default:
! 465: ;
! 466: }
! 467: }
! 468: /* Erase any embedded prototype parameters. */
! 469: if ( lp )
! 470: writeblanks(lp + 1, rp);
! 471: p--; /* back up over terminator */
! 472: /* Find the name being declared. */
! 473: /* This is complicated because of procedure and */
! 474: /* array modifiers. */
! 475: for ( ; ; )
! 476: { p = skipspace(p - 1, -1);
! 477: switch ( *p )
! 478: {
! 479: case ']': /* skip array dimension(s) */
! 480: case ')': /* skip procedure args OR name */
! 481: { int level = 1;
! 482: while ( level )
! 483: switch ( *--p )
! 484: {
! 485: case ']': case ')': level++; break;
! 486: case '[': case '(': level--; break;
! 487: case '/': p = skipspace(p, -1) + 1; break;
! 488: default: ;
! 489: }
! 490: }
! 491: if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
! 492: { /* We found the name being declared */
! 493: while ( !isidfirstchar(*p) )
! 494: p = skipspace(p, 1) + 1;
! 495: goto found;
! 496: }
! 497: break;
! 498: default:
! 499: goto found;
! 500: }
! 501: }
! 502: found: if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
! 503: { if ( convert_varargs )
! 504: { *bp++ = "va_alist";
! 505: vararg = p-2;
! 506: }
! 507: else
! 508: { p++;
! 509: if ( bp == breaks + 1 ) /* sole argument */
! 510: writeblanks(breaks[0], p);
! 511: else
! 512: writeblanks(bp[-1] - 1, p);
! 513: bp--;
! 514: }
! 515: }
! 516: else
! 517: { while ( isidchar(*p) ) p--;
! 518: *bp++ = p+1;
! 519: }
! 520: p = end;
! 521: }
! 522: while ( *p++ == ',' );
! 523: *bp = p;
! 524: /* Make a special check for 'void' arglist */
! 525: if ( bp == breaks+2 )
! 526: { p = skipspace(breaks[0], 1);
! 527: if ( !strncmp(p, "void", 4) )
! 528: { p = skipspace(p+4, 1);
! 529: if ( p == breaks[2] - 1 )
! 530: { bp = breaks; /* yup, pretend arglist is empty */
! 531: writeblanks(breaks[0], p + 1);
! 532: }
! 533: }
! 534: }
! 535: /* Put out the function name and left parenthesis. */
! 536: p = buf;
! 537: while ( p != endfn ) putc(*p, out), p++;
! 538: /* Put out the declaration. */
! 539: if ( header )
! 540: { fputs(");", out);
! 541: for ( p = breaks[0]; *p; p++ )
! 542: if ( *p == '\r' || *p == '\n' )
! 543: putc(*p, out);
! 544: }
! 545: else
! 546: { for ( ap = breaks+1; ap < bp; ap += 2 )
! 547: { p = *ap;
! 548: while ( isidchar(*p) )
! 549: putc(*p, out), p++;
! 550: if ( ap < bp - 1 )
! 551: fputs(", ", out);
! 552: }
! 553: fputs(") ", out);
! 554: /* Put out the argument declarations */
! 555: for ( ap = breaks+2; ap <= bp; ap += 2 )
! 556: (*ap)[-1] = ';';
! 557: if ( vararg != 0 )
! 558: { *vararg = 0;
! 559: fputs(breaks[0], out); /* any prior args */
! 560: fputs("va_dcl", out); /* the final arg */
! 561: fputs(bp[0], out);
! 562: }
! 563: else
! 564: fputs(breaks[0], out);
! 565: }
! 566: free((char *)breaks);
! 567: return 0;
! 568: }
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 / lrzsz / src