# 1 "ansi2knr.c"
 


















 
 
# 1 "D:/EMX/INCLUDE/stdio.h" 1 3
 










typedef unsigned long size_t;












struct _FILE
{
  char * ptr;
  char * buffer;
  int    rcount;
  int    wcount;
  int    handle;
  int    flags;
  int    buf_size;
  int    tmpidx;
  int    pid;
  char   char_buf;
  char   reserved1[3];
  int    (*flush)(struct _FILE *f, int c);
  unsigned long sem;
};

typedef struct _FILE FILE;

extern FILE _streamv[];















































typedef long fpos_t;




typedef char *va_list;


void clearerr (FILE *stream);
int fclose (FILE *stream);
int fcloseall (void);
FILE *fdopen (int handle, __const__ char *mode);
int fflush (FILE *stream);
int fgetc (FILE *stream);
int fgetchar (void);
int fgetpos (FILE *stream, fpos_t *pos);
char *fgets (char *buffer, int n, FILE *stream);
int flushall (void);
FILE *fopen (__const__ char *fname, __const__ char *mode);
int fprintf (FILE *stream, __const__ char *format, ...);
int fputc (int c, FILE *stream);
int fputchar (int c);
int fputs (__const__ char *string, FILE *stream);
size_t fread (void *buffer, size_t size, size_t count, FILE *stream);
FILE *freopen (__const__ char *fname, __const__ char *mode, FILE *stream);
int fscanf (FILE *stream, __const__ char *format, ...);
int fseek (FILE *stream, long offset, int origin);
int fsetpos (FILE *stream, __const__ fpos_t *pos);
long ftell (FILE *stream);
size_t fwrite (__const__ void *buffer, size_t size, size_t count,
    FILE *stream);
char *gets (char *buffer);
int getw (FILE *stream);
int pclose (FILE *stream);
void perror (__const__ char *string);
FILE *popen (__const__ char *command, __const__ char *mode);
int printf (__const__ char *format, ...);
int puts (__const__ char *string);
int putw (int x, FILE *stream);
int remove (__const__ char *name);
int rename (__const__ char *old_name, __const__ char *new_name);
void rewind (FILE *stream);
int _rmtmp (void);
int scanf (__const__ char *format, ...);
int setbuf (FILE *stream, char *buffer);
int setbuffer (FILE *stream, char *buffer, size_t size);
int setvbuf (FILE *stream, char *buffer, int mode, size_t size);
int sprintf (char *buffer, __const__ char *format, ...);
int sscanf (__const__ char *buffer, __const__ char *format, ...);
char *tempnam (__const__ char *dir, __const__ char *prefix);
FILE *tmpfile (void);
char *tmpnam (char *string);
int ungetc (int c, FILE *stream);
int unlink (__const__ char *name);
int vfprintf (FILE *stream, __const__ char *format, va_list arg_ptr);
int vfscanf (FILE *stream, __const__ char *format, va_list arg_ptr);
int vprintf (__const__ char *format, va_list arg_ptr);
int vscanf (__const__ char *format, va_list arg_ptr);
int vsprintf (char *buffer, __const__ char *format, va_list arg_ptr);
int vsscanf (__const__ char *buffer, __const__ char *format, va_list arg_ptr);

int _fill (FILE *stream);
int _flush (int c, FILE *stream);

int _fseek_hdr (FILE *stream);
FILE *_fsopen (__const__ char *fname, __const__ char *mode, int shflag);

static __inline__ int fileno (FILE *s) { return (s->handle); }
static __inline__ int feof (FILE *s) { return (s->flags &  0x08  ? 1 : 0); }
static __inline__ int ferror (FILE *s) { return (s->flags &  0x10  ? 1 : 0); }








static __inline__ int getc (FILE *s)
{
  return (--s->rcount >= 0
          ? (unsigned char)*s->ptr++
          : _fill (s));
}

static __inline__ int putc (int c, FILE *s)
{
  return (--s->wcount >= 0 && (c != '\n' || !(s->flags &  0x20 ))
          ? (unsigned char)(*s->ptr++ = (char)c)
          : _flush (c, s));
}



static __inline__ int getchar (void) { return (getc ( (&_streamv[0]) )); }
static __inline__ int putchar (int c) { return (putc (c, (&_streamv[1]) )); }






# 22 "ansi2knr.c" 2

# 1 "D:/EMX/INCLUDE/ctype.h" 1 3
 









extern unsigned char _ctype[];











































static __inline__ int _toupper (int c) { return (c-'a'+'A'); }
static __inline__ int _tolower (int c) { return (c-'A'+'a'); }
static __inline__ int toupper(int c) {return (  ((_ctype+1)[c] & ( 0x02 ))   ? _toupper(c) : c);}
static __inline__ int tolower(int c) {return (  ((_ctype+1)[c] & ( 0x01 ))   ? _tolower(c) : c);}







# 23 "ansi2knr.c" 2

extern char *xmalloc ();

extern char *index ();





 

















 



main(argc, argv)
    int argc;
    char *argv[];
{	FILE *in, *out;

	char buf[500			];
	char *line;
	switch ( argc )
	   {
	default:
		printf("Usage: ansi2knr input_file [output_file]\n");
		exit(0);
	case 2:
		out = (&_streamv[1]) ; break;
	case 3:
		out = fopen(argv[2], "w");
		if ( out == ((void *)0)  )
		   {	fprintf((&_streamv[2]) , "Cannot open %s\n", argv[2]);
			exit(1);
		   }
	   }
	in = fopen(argv[1], "r");
	if ( in == ((void *)0)  )
	   {	fprintf((&_streamv[2]) , "Cannot open %s\n", argv[1]);
		exit(1);
	   }
	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
	line = buf;
	while ( fgets(line, (unsigned)(buf + 500			 - line), in) != ((void *)0)  )
	   {	switch ( test1(buf) )
		   {
		case 1:			 
			convert1(buf, out);
			break;
		case -1:		 
			line = buf + strlen(buf);
			continue;
		default:		 
			fputs(buf, out);
			break;
		   }
		line = buf;
	   }
	if ( line != buf ) fputs(buf, out);
	fclose(out);
	fclose(in);
	return 0;
}

 
char *
skipspace(p, dir)
    register char *p;
    register int dir;			 
{	for ( ; ; )
	   {	while (   ((_ctype+1)[*p] & ( 0x20 ))   ) p += dir;
		if ( !(*p == '/' && p[dir] == '*') ) break;
		p += dir;  p += dir;
		while ( !(*p == '*' && p[dir] == '/') )
		   {	if ( *p == 0 ) return p;	 
			p += dir;
		   }
		p += dir;  p += dir;
	   }
	return p;
}

 


void
writeblanks(start, end)
    char *start;
    char *end;
{	char *p;
	for ( p = start; p < end; p++ ) *p = ' ';
}

 








test1(buf)
    char *buf;
{	register char *p = buf;
	char *bend;
	char *endfn;
	int contin;
	if ( !(  ((_ctype+1)[*p] & ( 0x01 | 0x02 ))   || (*p) == '_')  )
		return 0;		 
	bend = skipspace(buf + strlen(buf) - 1, -1);
	switch ( *bend )
	   {
	case ')': contin = 1; break;
	case '(':
	case ',': contin = -1; break;
	default: return 0;		 
	   }
	while ( (  ((_ctype+1)[*p] & ( 0x01 | 0x02 | 0x04 ))   || (*p) == '_')  ) p++;
	endfn = p;
	p = skipspace(p, 1);
	if ( *p++ != '(' )
		return 0;		 
	p = skipspace(p, 1);
	if ( *p == ')' )
		return 0;		 
	 
	 
	 
	   {	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 - buf;
		while ( (kp = *key) != 0 )
		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
				return 0;	 
			key++;
		   }
	   }
	return contin;
}

convert1(buf, out)
    char *buf;
    FILE *out;
{	char *endfn = index (buf, '(') + 1;
	register char *p;
	char **breaks;
	unsigned num_breaks = 2;	 
	char **btop;
	char **bp;
	char **ap;
top:	p = endfn;
	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
	if ( breaks == 0 )
	   {	 
		fprintf((&_streamv[2]) , "Unable to allocate break table!\n");
		fputs(buf, out);
		return -1;
	   }
	btop = breaks + num_breaks * 2 - 2;
	bp = breaks;
	 
	do
	   {	int level = 0;
		char *end = ((void *)0) ;
		if ( bp >= btop )
		   {	 
			 
			free((char *)breaks);
			num_breaks <<= 1;
			goto top;
		   }
		*bp++ = p;
		 
		for ( ; end == ((void *)0) ; p++ )
		   {	switch(*p)
			   {
			case ',': if ( !level ) end = p; break;
			case '(': level++; break;
			case ')': if ( --level < 0 ) end = p; break;
			case '/': p = skipspace(p, 1) - 1; break;
			default: ;
			   }
		   }
		p--;			 
		 
		 
		 
		for ( ; ; )
		   {	p = skipspace(p - 1, -1);
			switch ( *p )
			   {
			case ']':	 
			case ')':	 
			   {	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) == '*' )
				   {	 
					while ( !(  ((_ctype+1)[*p] & ( 0x01 | 0x02 ))   || (*p) == '_')  )
						p = skipspace(p, 1) + 1;
					goto found;
				   }
				break;
			default: goto found;
			   }
		   }
found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
		   {	p++;
			if ( bp == breaks + 1 )	 
				writeblanks(breaks[0], p);
			else
				writeblanks(bp[-1] - 1, p);
			bp--;
		   }
		else
		   {	while ( (  ((_ctype+1)[*p] & ( 0x01 | 0x02 | 0x04 ))   || (*p) == '_')  ) p--;
			*bp++ = p+1;
		   }
		p = end;
	   }
	while ( *p++ == ',' );
	*bp = p;
	 
	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;	 
				writeblanks(breaks[0], p + 1);
			   }
		   }
	   }
	 
	p = buf;
	while ( p != endfn ) putc(*p, out), p++;
	 
	for ( ap = breaks+1; ap < bp; ap += 2 )
	   {	p = *ap;
		while ( (  ((_ctype+1)[*p] & ( 0x01 | 0x02 | 0x04 ))   || (*p) == '_')  ) putc(*p, out), p++;
		if ( ap < bp - 1 ) fputs(", ", out);
	   }
	fputs(")  ", out);
	 
	for ( ap = breaks+2; ap <= bp; ap += 2 ) (*ap)[-1] = ';';
	fputs(breaks[0], out);
	free((char *)breaks);
	return 0;
}
