src/autoconf/ansi2knr.c

/* Copyright (C) 1989, 1997, 1998 Aladdin Enterprises.  All rights reserved. */

/*$Id: ansi2knr.c,v 1.1.1.1 2002/12/27 08:45:08 dizzy Exp $*/
/* Convert ANSI C function definitions to K&R ("traditional C") syntax */

/*
ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY.  No author or distributor accepts responsibility to anyone for the
consequences of using it or for whether it serves any particular purpose or
works at all, unless he says so in writing.  Refer to the GNU General Public
License (the "GPL") for full details.

Everyone is granted permission to copy, modify and redistribute ansi2knr,
but only under the conditions described in the GPL.  A copy of this license
is supposed to have been given to you along with ansi2knr so you can know
your rights and responsibilities.  It should be in a file named COPYLEFT,
or, if there is no file named COPYLEFT, a file named COPYING.  Among other
things, the copyright notice and this notice must be preserved on all
copies.

We explicitly state here what we believe is already implied by the GPL: if
the ansi2knr program is distributed as a separate set of sources and a
separate executable file which are aggregated on a storage medium together
with another program, this in itself does not bring the other program under
the GPL, nor does the mere fact that such a program or the procedures for
constructing it invoke the ansi2knr executable bring any other part of the
program under the GPL.
*/

/*
 * Usage:
        ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]
 * --filename provides the file name for the #line directive in the output,
 * overriding input_file (if present).
 * If no input_file is supplied, input is read from stdin.
 * If no output_file is supplied, output goes to stdout.
 * There are no error messages.
 *
 * ansi2knr recognizes function definitions by seeing one or more
 * identifiers at the left margin, possibly including function pointer
 * types, eventually followed by a left parenthesis with a right
 * parenthesis after that and with a left brace as the first token on
 * the next line.  ansi2knr will recognize a multi-line header provided
 * that no intervening line ends with a left or right brace or a
 * semicolon.  These algorithms ignore whitespace and comments.
 * The following constructs will confuse it:
 *      - Any other construct that starts at the left margin and
 *          follows the above syntax (such as a macro or function call).
 *      - Some macros that tinker with the syntax of the function header.
 */

/*
 * The original and principal author of ansi2knr is L. Peter Deutsch
 * <ghost@aladdin.com>.  Other authors are noted in the change history
 * that follows (in reverse chronological order):
        rac 2000-08-02 modified to not force the return values to be
                on the preceding line, to transform prototypes, to
                remove the "void" single parameter restriction, and to
                handle function pointers with ANSI style parameters.
        lpd 1998-11-09 added further hack to recognize identifier(void)
                as being a procedure
        lpd 1998-10-23 added hack to recognize lines consisting of
                identifier1(identifier2) as *not* being procedures
        lpd 1997-12-08 made input_file optional; only closes input and/or
                output file if not stdin or stdout respectively; prints
                usage message on stderr rather than stdout; adds
                --filename switch (changes suggested by
                <ceder@lysator.liu.se>)
        lpd 1996-01-21 added code to cope with not HAVE_CONFIG_H and with
                compilers that don't understand void, as suggested by
                Tom Lane
        lpd 1996-01-15 changed to require that the first non-comment token
                on the line following a function header be a left brace,
                to reduce sensitivity to macros, as suggested by Tom Lane
                <tgl@sss.pgh.pa.us>
        lpd 1995-06-22 removed #ifndefs whose sole purpose was to define
                undefined preprocessor symbols as 0; changed all #ifdefs
                for configuration symbols to #ifs
        lpd 1995-04-05 changed copyright notice to make it clear that
                including ansi2knr in a program does not bring the entire
                program under the GPL
        lpd 1994-12-18 added conditionals for systems where ctype macros
                don't handle 8-bit characters properly, suggested by
                Francois Pinard <pinard@iro.umontreal.ca>;
                removed --varargs switch (this is now the default)
        lpd 1994-10-10 removed CONFIG_BROKETS conditional
        lpd 1994-07-16 added some conditionals to help GNU `configure',
                suggested by Francois Pinard <pinard@iro.umontreal.ca>;
                properly erase prototype args in function parameters,
                contributed by Jim Avera <jima@netcom.com>;
                correct error in writeblanks (it shouldn't erase EOLs)
        lpd 1989-xx-xx original version
 */

/* Most of the conditionals here are to make ansi2knr work with */
/* or without the GNU configure machinery. */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include <stdio.h>
#include <ctype.h>

#if HAVE_CONFIG_H

/*
   For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
   This will define HAVE_CONFIG_H and so, activate the following lines.
 */

# if STDC_HEADERS || HAVE_STRING_H
#  include <string.h>
# else
#  include <strings.h>
# endif

#else /* not HAVE_CONFIG_H */

/* Otherwise do it the hard way */

# ifdef BSD
#  include <strings.h>
# else
#  ifdef VMS
    extern int strlen(), strncmp();
#  else
#   include <string.h>
#  endif
# endif

#endif /* not HAVE_CONFIG_H */

#if STDC_HEADERS
# include <stdlib.h>
#else
/*
   malloc and free should be declared in stdlib.h,
   but if you've got a K&R compiler, they probably aren't.
 */
# ifdef MSDOS
#  include <malloc.h>
# else
#  ifdef VMS
     extern char *malloc();
     extern void free();
#  else
     extern char *malloc();
     extern int free();
#  endif
# endif

#endif

/*
 * The ctype macros don't always handle 8-bit characters correctly.
 * Compensate for this here.
 */
#ifdef isascii
#  undef HAVE_ISASCII           /* just in case */
#  define HAVE_ISASCII 1
#else
#endif
#if STDC_HEADERS || !HAVE_ISASCII
#  define is_ascii(c) 1
#else
#  define is_ascii(c) isascii(c)
#endif

#define is_space(c) (is_ascii(c) && isspace(c))
#define is_alpha(c) (is_ascii(c) && isalpha(c))
#define is_alnum(c) (is_ascii(c) && isalnum(c))

/* Scanning macros */
#define isidchar(ch) (is_alnum(ch) || (ch) == '_')
#define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')

/* Forward references */
static char *skipspace();
static int writeblanks();
static int test1();
static int convert1();

static char *startfn;
static char *endfn;

/* The main program */
int
main(argc, argv)
    int argc;
    char *argv[];
{       FILE *in = stdin;
        FILE *out = stdout;
        char *filename = 0;
#define bufsize 5000                    /* arbitrary size */
        char *buf;
        char *line;
        char *more;
        char *usage =
          "Usage: ansi2knr [--filename FILENAME] [INPUT_FILE [OUTPUT_FILE]]\n";
        /*
         * In previous versions, ansi2knr recognized a --varargs switch.
         * If this switch was supplied, ansi2knr would attempt to convert
         * a ... argument to va_alist and va_dcl; if this switch was not
         * supplied, ansi2knr would simply drop any such arguments.
         * Now, ansi2knr always does this conversion, and we only
         * check for this switch for backward compatibility.
         */
        int convert_varargs = 1;

        while ( argc > 1 && argv[1][0] == '-' ) {
          if ( !strcmp(argv[1], "--varargs") ) {
            convert_varargs = 1;
            argc--;
            argv++;
            continue;
          }
          if ( !strcmp(argv[1], "--filename") && argc > 2 ) {
            filename = argv[2];
            argc -= 2;
            argv += 2;
            continue;
          }
          fprintf(stderr, "Unrecognized switch: %s\n", argv[1]);
          fprintf(stderr, usage);
          exit(1);
        }
        switch ( argc )
           {
        default:
                fprintf(stderr, usage);
                exit(0);
        case 3:
                out = fopen(argv[2], "w");
                if ( out == NULL ) {
                  fprintf(stderr, "Cannot open output file %s\n", argv[2]);
                  exit(1);
                }
                /* falls through */
        case 2:
                in = fopen(argv[1], "r");
                if ( in == NULL ) {
                  fprintf(stderr, "Cannot open input file %s\n", argv[1]);
                  exit(1);
                }
                if ( filename == 0 )
                  filename = argv[1];
                /* falls through */
        case 1:
                break;
           }
        if ( filename )
          fprintf(out, "#line 1 \"%s\"\n", filename);
        buf = malloc(bufsize);
        line = buf;
        while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
           {
test:           line += strlen(line);
                switch ( test1(buf) )
                   {
                case 3:                 /* a function pointer */
                case 2:                 /* a function prototype */
                        convert1(buf, out, 1, convert_varargs);
                        break;
                case 1:                 /* a function */
                        /* Check for a { at the start of the next line. */
                        more = ++line;
f:                      if ( line >= buf + (bufsize - 1) ) /* overflow check */
                          goto wl;
                        if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
                          goto wl;
                        switch ( *skipspace(more, 1) )
                          {
                          case '{':
                            /* Definitely a function */
                            convert1(buf, out, 0, convert_varargs);
                            fputs(more, out);
                            break;
                          case 0:
                            /* The next line was blank or a comment: */
                            /* keep scanning for a non-comment. */
                            line += strlen(line);
                            goto f;
                          default:
                            /* buf isn't a function header, but */
                            /* more might be. */
                            fputs(buf, out);
                            strcpy(buf, more);
                            line = buf;
                            goto test;
                          }
                        break;
                case -1:                /* maybe the start of a function */
                        if ( line != buf + (bufsize - 1) ) /* overflow check */
                          continue;
                        /* falls through */
                default:                /* not a function */
wl:                     fputs(buf, out);
                        break;
                   }
                line = buf;
           }
        if ( line != buf )
          fputs(buf, out);
        free(buf);
        if ( out != stdout )
          fclose(out);
        if ( in != stdin )
          fclose(in);
        return 0;
}


/* Skip over space and comments, in either direction. */
static char *
skipspace(p, dir)
    char *p;
    int dir;                    /* 1 for forward, -1 for backward */
{       if (*p=='\0') return p;
        for ( ; ; )
           {    while ( is_space(*p) )
                  p += dir;
                if ( !(*p == '/' && p[dir] == '*') )
                  break;
                p += dir;  p += dir;
                while ( !(*p == '*' && p[dir] == '/') )
                   {    if ( *p == 0 )
                          return p;     /* multi-line comment?? */
                        p += dir;
                   }
                p += dir;  p += dir;
           }
        return p;
}

/*
 * Write blanks over part of a string.
 * Don't overwrite end-of-line characters.
 */
static int
writeblanks(start, end)
    char *start;
    char *end;
{       char *p;
        for ( p = start; p < end; p++ )
          if ( *p != '\r' && *p != '\n' )
            *p = ' ';
        return 0;
}

/*
 * Test whether the string in buf is a function definition.
 * The string may contain and/or end with a newline.
 * Return as follows:
 *      0 - definitely not a function definition;
 *      1 - definitely a function definition;
 *      2 - definitely a function prototype;
 *      3 - definitely a function pointer;
 *      -1 - may be the beginning of a function definition,
 *              append another line and look again.
 */
static int
test1(buf)
    char *buf;
{       char *p;
        char *bend;
        int contin;

        if ( !isalpha(*buf) )
          return 0;             /* no name at left margin */
        bend = skipspace(buf + strlen(buf) - 1, -1);
        switch ( *bend )
           {
           case ';': contin = 2; break;
           case ')': contin = 1; break;
           case '{':
           case '}':
             return 0;          /* not a function */
           default: contin = -1;
           }

        /* find start and end of function name */
        startfn=buf;
        while (*startfn!='\0' && *startfn!='(')
          {
            startfn++;
            startfn = skipspace(startfn, 1);
          }
        if (*startfn=='\0')
            return 0;           /* not a function */
        startfn--;
        p = startfn;
        startfn = skipspace(startfn,-1);
        endfn = startfn+1;
        while (isidchar(*startfn)) startfn--;
        startfn++;
        if (startfn>=endfn)
            return 0;
        
        p = skipspace(endfn, 1);
#if 0
/*                   v         v */
/* typedef __ssize_t __io_read_  */
fprintf(stderr,"found %s\n",buf);
fprintf(stderr,"func=");
{ int i; for (i=0; i<endfn-startfn; i++) fprintf(stderr,"%c",startfn[i]); }
fprintf(stderr,"\n");
fprintf(stderr,"p=%s\n",p);
#endif
        p++; /* skip ( */
        p = skipspace(p, 1);
        if (*p=='*')  /* maybe a function pointer */
          {
            startfn = p;
            while (*p!='\0' && *p!=')')
                p++;
            if (*p=='\0')
                return -1;  /* wraps to the next line */
            endfn = p-1;
            if (contin!=-1) contin = 3;
          }
        else
            if (!isidfirstchar(*p))
                return 0;  /* ok... no parameters anyway */
        
        /* Check that the apparent function name isn't a keyword. */
        /* We only need to check for keywords that could be followed */
        /* by a left parenthesis (which, unfortunately, is most of them). */
        if (contin != 3)
        {  static char *words[] =
             {  "asm", "auto", "case", "char", "const", "double",
                "extern", "float", "for", "if", "int", "long",
                "register", "return", "short", "signed", "sizeof",
                "static", "switch", "typedef", "unsigned",
                "void", "volatile", "while", 0
             };
          char **key = words;
          char *kp;
          int len = endfn - startfn;

          while ( (kp = *key) != 0 )
            {   if ( strlen(kp) == len && !strncmp(kp, startfn, len) )
                {
                  fprintf(stderr,"it was a keyword\n");
                  return 0;     /* name is a keyword */
                }
                key++;
            }
        }
        /*
         * If the last significant character was a ), we need to count
         * parentheses, because it might be part of a formal parameter
         * that is a procedure.
         */
        if (contin > 0) {
            int level = 0;

            for (p = endfn; *p; p = skipspace(p + 1, 1))
                level += (*p == '(' ? 1 : *p == ')' ? -1 : 0);
            if (level > 0)
                contin = -1;
        }
        return contin;
}

/* Convert a recognized function definition or header to K&R syntax. */
static int
convert1(buf, out, header, convert_varargs)
    char *buf;
    FILE *out;
    int header;                 /* Boolean */
    int convert_varargs;        /* Boolean */
{
        char *p;
        /*
         * The breaks table contains pointers to the beginning and end
         * of each argument.
         */
        char **breaks;
        unsigned num_breaks = 2;        /* for testing */
        char **btop;
        char **bp;
        char **ap;
        char *vararg = 0;

        for (p=buf; p<startfn; p++)
          fprintf(out,"%c",*p);
        
        while (*(endfn++) != '(');
        
top:    p = endfn;
        breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
        if ( breaks == 0 )
           {    /* Couldn't allocate break table, give up */
                fprintf(stderr, "Unable to allocate break table!\n");
                fputs(startfn, out);
                return -1;
           }
        btop = breaks + num_breaks * 2 - 2;
        bp = breaks;
        /* Parse the argument list */
        do
           {    int level = 0;
                char *lp = NULL;
                char *rp;
                char *end = NULL;

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