################################################################
## Need to hide certain names such as _doprnt, _doscan
################################################################

#pragma weak note{ compile system supports symbol transform }end link{
#	main() { return _xyz(); }
#	#pragma weak   _xyz =  __xyz
#	#define	        _xyz    __xyz
#	_xyz() { return 0; }
#}end

################################################################
## To emulate old-style stdio at binary level
################################################################

tst - output{
	#include	<stdio.h>
	main() { printf("#define _siz_fpos_t	%d\n", sizeof(fpos_t)); exit(0); }
}end

FILE _cnt note{ field FILE.__cnt exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->__cnt == 0) ? 0 : -1; }
}end
FILE _ptr note{ field FILE.__ptr exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->__ptr == 0) ? 0 : -1; }
}end
FILE _file note{ field FILE.__file exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->__file == 0) ? 0 : -1; }
}end
FILE _flag note{ field FILE.__flag exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->__flag == 0) ? 0 : -1; }
}end

FILE cnt note{ field FILE._cnt exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->_cnt == 0) ? 0 : -1; }
}end
FILE ptr note{ field FILE._ptr exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->_ptr == 0) ? 0 : -1; }
}end
FILE file note{ field FILE._file exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->_file == 0) ? 0 : -1; }
}end
FILE flag note{ field FILE._flag exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->_flag == 0) ? 0 : -1; }
}end
FILE flags note{ field FILE._flags exists }end compile{
	#include	<stdio.h>
	main() { return (stdin->_flags == 0) ? 0 : -1; }
}end

cat{
	#if _FILE__cnt && ! _FILE_cnt
	#define _FILE_cnt	1
	#define _cnt		__cnt
	#endif
	#if _FILE__ptr && ! _FILE_ptr
	#define _FILE_ptr	1
	#define _ptr		__ptr
	#endif
	#if _FILE__flag && ! _FILE_flag
	#define _FILE_flag	1
	#define _flag		__flag
	#endif
	#if _FILE__file && ! _FILE_file
	#define _FILE_file	1
	#define _file		__file
	#endif
}end

############################################################################
# To emulate Linux-stdio at binary level
############################################################################
FILE readptr note{ fields FILE._IO_read_ptr/end exist }end execute{
	#include	<stdio.h>
	main()
	{ if(sizeof(stdin->_IO_read_ptr) != sizeof(char*) ) return 1;
	  if(sizeof(stdin->_IO_read_end) != sizeof(char*) ) return 1;
	  return 0;
	}
}end
FILE writeptr note{ fields FILE._IO_write_ptr/end exist }end execute{
	#include	<stdio.h>
	main()
	{ if(sizeof(stdin->_IO_write_ptr) != sizeof(char*) ) return 1;
	  if(sizeof(stdin->_IO_write_end) != sizeof(char*) ) return 1;
	  return 0;
	}
}end
FILE flags note{ field FILE._flags exists }end compile{
	#include	<stdio.h>
	main()
	{ return stdin->_flags == 0 ? 1 : 0;
	}
}end
FILE fileno note{ field FILE._fileno exists }end compile{
	#include	<stdio.h>
	main()
	{ return stdin->_fileno == 0 ? 1 : 0;
	}
}end
u flow note{ uflow() does bump buffer }end execute{
	#include	<stdio.h>
	#if _STD_
	main(int argc, char** argv)
	#else
	main(argc,argv)
	int     argc;
	char**  argv;
	#endif
	{ FILE*	f;
	  char	file[BUFSIZ];
	  sprintf(file,"%s.D",argv[0]);
	  if(!(f = fopen(file,"w+")) )
		exit(1);
	  unlink(file);
	  setbuf(f,file);
	  fputs("123456789",f);
	  fseek(f,0L,0);
	  if(__uflow(f) == EOF)
		exit(1);
	  if(*f->_IO_read_ptr == '1')
		exit(1);
	  else	exit(0);
	}
}end
under flow note{ underflow() does not bump buffer }end execute{
	#include	<stdio.h>
	#if _STD_
	main(int argc, char** argv)
	#else
	main(argc,argv)
	int     argc;
	char**  argv;
	#endif
	{ FILE*	f;
	  char	file[BUFSIZ];
	  sprintf(file,"%s.D",argv[0]);
	  if(!(f = fopen(file,"w+")) )
		exit(1);
	  unlink(file);
	  setbuf(f,file);
	  fputs("123456789",f);
	  fseek(f,0L,0);
	  if(__underflow(f) == EOF)
		exit(1);
	  if(*f->_IO_read_ptr == '1')
		exit(0);
	  else	exit(1);
	}
}end

######################################################################
# To emulate BSD-style stdio
######################################################################
FILE p	note{ FILE._p field }end compile{
	#include <stdio.h>
	main() { return stdin->_p == 0 ? 0 : 1; }
}end
FILE r	note{ FILE._r field }end compile{
	#include <stdio.h>
	main() { return stdin->_r == 0 ? 0 : 1; }
}end
FILE w	note{ FILE._w field }end compile{
	#include <stdio.h>
	main() { return stdout->_w == 0 ? 0 : 1; }
}end

lib __swbuf
lib __srget

lib __uflow
lib __underflow
lib __overflow

lib _IO_getc
lib _IO_putc

lib clearerr_unlocked
lib feof_unlocked
lib ferror_unlocked
lib fflush_unlocked
lib fgetc_unlocked
lib fgets_unlocked
lib fileno_unlocked
lib fputc_unlocked
lib fputs_unlocked
lib fread_unlocked
lib fwrite_unlocked
lib getc_unlocked
lib getchar_unlocked
lib putc_unlocked
lib putchar_unlocked

lib __snprintf
lib __vsnprintf

# detect microsoft dll declaration of _iob
mac	_iob	stdio.h
msft	iob note{ microsoft's oddity }end compile{
	#include	<stdio.h>
	#if _mac__iob
	_CRTIMP extern FILE * __cdecl __p__iob(void);
	FILE* foo() { return &(_iob[0]); }
	#else
	this should fail;
	#endif
}end

dat	_iob,__iob	stdio.h
native	iob note{ ok to use stdio's _iob }end compile{
	#define	_doprnt		_____doprnt
	#define	_doscan		_____doscan
	#define	fclose		____fclose
	#define	fdopen		____fdopen
	#define	fflush		____fflush
	#define	fgetc		____fgetc
	#define	fgets		____fgets
	#define	_filbuf		_____filbuf
	#define	_flsbuf		_____flsbuf
	#define	_cleanup	_____cleanup
	#define	fopen		____fopen
	#define	fprintf		____fprintf
	#define	fputc		____fputc
	#define	fputs		____fputs
	#define	fread		____fread
	#define	freopen		____freopen
	#define	fscanf		____fscanf
	#define	fseek		____fseek
	#define	ftell		____ftell
	#define	fgetpos		____fgetpos
	#define	fsetpos		____fsetpos
	#define	fpurge		____fpurge
	#define	fwrite		____fwrite
	#define	gets		____gets
	#define	getw		____getw
	#define	pclose		____pclose
	#define	popen		____popen
	#define	printf		____printf
	#define	puts		____puts
	#define	putw		____putw
	#define	rewind		____rewind
	#define	scanf		____scanf
	#define	setbuf		____setbuf
	#define	setbuffer	____setbuffer
	#define	setlinebuf	____setlinebuf
	#define	setvbuf		____setvbuf
	#define	sprintf		____sprintf
	#define	sscanf		____sscanf
	#define	tmpfile		____tmpfile
	#define	ungetc		____ungetc
	#define	vfprintf	____vfprintf
	#define	vfscanf		____vfscanf
	#define	vprintf		____vprintf
	#define	vscanf		____vscanf
	#define	vsprintf	____vsprintf
	#define	vsscanf		____vsscanf
	#define	flockfile	____flockfile
	#define	funlockfile	____funlockfile
	#define	ftrylockfile	____ftrylockfile
	
	#include	<stdio.h>
	
	#undef IOB
	#if defined(_dat_iob) && !defined(IOB)
	#define IOB	iob
	#endif
	#if defined(_dat__iob) && !defined(IOB)
	#define IOB	_iob
	#endif
	#if defined(_dat___iob) && !defined(IOB)
	#define IOB	__iob
	#endif
	
	static void* addr() { return((void*)IOB); }
	int main() { addr(); exit(0); }
	
	#undef	_doprnt
	#undef	_doscan
	#undef	fclose
	#undef	fdopen
	#undef	fflush
	#undef	fgetc
	#undef	fgets
	#undef	_filbuf
	#undef	_flsbuf
	#undef	_cleanup
	#undef	fopen
	#undef	fprintf
	#undef	fputc
	#undef	fputs
	#undef	fread
	#undef	freopen
	#undef	fscanf
	#undef	fseek
	#undef	ftell
	#undef	fgetpos
	#undef	fsetpos
	#undef	fpurge
	#undef	fwrite
	#undef	gets
	#undef	getw
	#undef	pclose
	#undef	popen
	#undef	printf
	#undef	puts
	#undef	putw
	#undef	rewind
	#undef	scanf
	#undef	setbuf
	#undef	setbuffer
	#undef	setlinebuf
	#undef	setvbuf
	#undef	sprintf
	#undef	sscanf
	#undef	tmpfile
	#undef	ungetc
	#undef	vfprintf
	#undef	vfscanf
	#undef	vprintf
	#undef	vscanf
	#undef	vsprintf
	#undef	vsscanf
	#undef	flockfile
	#undef	funlockfile
	#undef	ftrylockfile
	
	void	_doprnt() {}
	void	_doscan() {}
	void	fclose() {}
	void	fdopen() {}
	void	fflush() {}
	void	fgetc() {}
	void	fgets() {}
	void	_filbuf() {}
	void	_flsbuf() {}
	void	_cleanup() {}
	void	fopen() {}
	void	fprintf() {}
	void	fputc() {}
	void	fputs() {}
	void	fread() {}
	void	freopen() {}
	void	fscanf() {}
	void	fseek() {}
	void	ftell() {}
	void	fgetpos() {}
	void	fsetpos() {}
	void	fpurge() {}
	void	fwrite() {}
	void	gets() {}
	void	getw() {}
	void	pclose() {}
	void	popen() {}
	void	printf() {}
	void	puts() {}
	void	putw() {}
	void	rewind() {}
	void	scanf() {}
	void	setbuf() {}
	void	setbuffer() {}
	void	setlinebuf() {}
	void	setvbuf() {}
	void	sprintf() {}
	void	sscanf() {}
	void	tmpfile() {}
	void	ungetc() {}
	void	vfprintf() {}
	void	vfscanf() {}
	void	vprintf() {}
	void	vscanf() {}
	void	vsprintf() {}
	void	vsscanf() {}
	void	flockfile() {}
	void	funlockfile() {}
	void	ftrylockfile() {}
}end