	 kƜ z5z5by name         by name         BUILD           d   	kH      A                                                ./               A          A          
kbT 3 m            z5z5z5
                ./lpp_name               m          m          4 R S xlC.C++ {
xlC.C++.include 3.1.4.6 01 N U en_US C Set ++ for AIX Compiler Include Files
[
*prereq xlC.C++.include 3.1.4.0
%
/usr/lpp/xlC/include/net 8
/usr/lpp/SAVESPACE 104
/usr/lib/objrepos 8
/usr/lpp/xlC/include/rpc 8
/usr/lpp/xlC/include/sys 24
/usr/lpp/xlC/include 64
INSTWORK 56 24
%
%
%
IX60368  1 CSet generates incorrect include-end offsets
IX62244  1 svc_register() signature not valid C++
IX62242  1 sys/lockf.h should incl. standard lockf.h
IX64798  1 STREAMBUF ARRAY MEMBER NEEDS DELETE
IX68466  1 errno decl in complex.h has wrong linkage
IX70499  1 curses.h is missing a declaration of wgetch()
IX81585  1 sys/mount.h references missing file
%
]
}
    	k\      A                                                ./usr            A          A          
k{      A                                                ./usr/lpp                A          A          k>      A                                                ./usr/lpp/xlC.C++/xlC.C++.include/3.1.4.6                A          A          k + m            z5z5z5
                ./usr/lpp/xlC.C++/xlC.C++.include/3.1.4.6/liblpp.a               m          m          <aiaff>
4562        0           68          3278        0           19          190         0           860795683   1590        8100        644         9   productid `
xlC.C++ 5765-42100
   403         712         68          860795686   1590        8100        644         25  xlC.C++.include.copyright `
 Licensed Materials - Property of IBM

 576542100
   (C) Copyright International Business Machines Corp. 1990, 1996.
   (C) Copyright AT&T 1984, 1985, 1986, 1987, 1988, 1989.
   (C) Copyright Unix System Labs, Inc., a subsidiary of Novell, Inc. 1993.

 All rights reserved.
 US Government Users Restricted Rights - Use, duplication or disclosure
 restricted by GSA ADP Schedule Contract with IBM Corp.

   1821        2650        190         903707344   1590        8100        644         25  xlC.C++.include.inventory `
/usr/lpp/xlC/include/net/nh.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 33
          checksum = "10369     1 "

/usr/lpp/xlC/include/rpc/svc.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 522
          checksum = "46965     1 "

/usr/lpp/xlC/include/sys/lockf.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 36
          checksum = "08171     1 "

/usr/lpp/xlC/include/iostream.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 19147
          checksum = "03047    19 "

/usr/lpp/xlC/include/sys/time.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 476
          checksum = "28147     1 "

/usr/lpp/xlC/include/complex.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 4365
          checksum = "35989     5 "

/usr/lpp/xlC/include/curses.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 1367
          checksum = "59366     2 "

/usr/lpp/xlC/include/sys/mount.h:
          owner = bin
          group = bin
          mode = 444
          type = FILE
          class = apply,inventory,xlC.C++.include
          size = 55
          checksum = "56615     1 "

 149         2910        712         903707344   1590        8100        644         20  xlC.C++.include.size`
/usr/lpp/xlC/include/net 8
/usr/lpp/SAVESPACE 104
/usr/lib/objrepos 8
/usr/lpp/xlC/include/rpc 8
/usr/lpp/xlC/include/sys 24
/usr/lpp/xlC/include 64
 260         3278        2650        903707344   1590        8100        644         18  xlC.C++.include.al`
./usr/lpp/xlC/include/net/nh.h
./usr/lpp/xlC/include/rpc/svc.h
./usr/lpp/xlC/include/sys/lockf.h
./usr/lpp/xlC/include/iostream.h
./usr/lpp/xlC/include/sys/time.h
./usr/lpp/xlC/include/complex.h
./usr/lpp/xlC/include/curses.h
./usr/lpp/xlC/include/sys/mount.h
1169        4562        2910        903707342   1590        8100        644         23  xlC.C++.include.fixdata `
fix:
	name = IX60368
	abstract = CSet generates incorrect include-end offsets
	type = f
	filesets = "xlC.C++.include:3.1.4.1\n\
"
	symptom = ""

fix:
	name = IX62244
	abstract = svc_register() signature not valid C++
	type = f
	filesets = "xlC.C++.include:3.1.4.2\n\
"
	symptom = ""

fix:
	name = IX62242
	abstract = sys/lockf.h should incl. standard lockf.h
	type = f
	filesets = "xlC.C++.include:3.1.4.2\n\
"
	symptom = ""

fix:
	name = IX64798
	abstract = STREAMBUF ARRAY MEMBER NEEDS DELETE
	type = f
	filesets = "xlC.C++.include:3.1.4.3\n\
"
	symptom = ""

fix:
	name = IX68466
	abstract = errno decl in complex.h has wrong linkage
	type = f
	filesets = "xlC.C++.include:3.1.4.4\n\
"
	symptom = " The declaration of errno in the C++ header complex.h\n\
 file did not specify extern "C".  Since this is\n\
 a symbol defined by the system, the declaration has\n\
 been removed.\n\
"

fix:
	name = IX70499
	abstract = curses.h is missing a declaration of wgetch()
	type = f
	filesets = "xlC.C++.include:3.1.4.5\n\
"
	symptom = ""

fix:
	name = IX81585
	abstract = sys/mount.h references missing file
	type = f
	filesets = "xlC.C++.include:3.1.4.6\n\
"
	symptom = ""

 210         0           3278        0           0           0           0           0   `
6           68          190         712         2650        2910        3278        productid xlC.C++.include.copyright xlC.C++.include.inventory xlC.C++.include.size xlC.C++.include.al xlC.C++.include.fixdata   k޺   $        !   z51h5
         .  !       ./usr/lpp/xlC/include/net/nh.h           $          $          #include </usr/include/net/nh.h>
       k\   $        
  z5AB2c5
         J  
      ./usr/lpp/xlC/include/rpc/svc.h          $          $          /* @(#)86	1.7.2.1  system_include/rpc/svc.h, Includes/6000, C.C++.3.1.3, 9638.3 9/17/96 14:31:48  */
/*
 *   COMPONENT_NAME: xlC
 *
 *   FUNCTIONS: none
 *
 *   ORIGINS: 27
 *
 *
 *   (C) COPYRIGHT International Business Machines Corp. 1993
 *   All Rights Reserved
 *   Licensed Materials - Property of IBM
 *   US Government Users Restricted Rights - Use, duplication or
 *   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
struct sockaddr_in;
struct opaque_auth;
#include </usr/include/rpc/svc.h>
      kDG   $        $   z5AB2^5
           $       ./usr/lpp/xlC/include/sys/lockf.h                $          $          #include </usr/include/sys/lockf.h>
c/svk   $        J  z52c5
         m  J      ./usr/lpp/xlC/include/iostream.h                 $          $          /*ident       "@(#)cls4:incl-master/const-headers/iostream.h  1.6" */
/*******************************************************************************
 
C++ source for the C++ Language System, Release 3.0.  This product
is a new release of the original cfront developed in the computer
science research center of AT&T Bell Laboratories.

Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
Copyright (c) 1984, 1989, 1990 AT&T.  All Rights Reserved.

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
Laboratories, Inc.  The copyright notice above does not evidence
any actual or intended publication of such source code.

*******************************************************************************/

#ifndef IOSTREAMH
#define IOSTREAMH

#include <memory.h>
		/* Some inlines use memcpy */

/* If EOF is defined already verify that it is -1.  Otherwise
 * define it.
 */

#ifdef EOF
#	if EOF!=-1
#		define EOF (-1) 
#	endif
#else
#	define EOF (-1)
#endif

/* Don't worry about NULL not being 0 */
#ifndef NULL
#	define NULL 0
#endif

#define	zapeof(c) ((c)&0377)
	    /* extracts char from c. The critical requirement is
	     *      zapeof(EOF)!=EOF
	     * ((c)&0377) and ((unsigned char)(c)) are alternative definitions
	     * whose efficiency depends on compiler environment.
	     */

typedef long streampos ;
typedef long streamoff ;

class streambuf ;
class ostream ;
union ios_user_union;


class ios {
public: /* Some enums are declared in ios to avoid pollution of
	 * global namespace
	 */
	enum io_state	{ goodbit=0, eofbit=1, failbit=2, badbit=4, 
				hardfail=0200};
				/* hard fail can be set and reset internally,
				 * but not via public function */
	enum open_mode	{ in=1, out=2, ate=4, app=010, trunc=020,
				nocreate=040, noreplace=0100} ;
	enum seek_dir	{ beg=0, cur=1, end=2 } ;

	/* flags for controlling format */
	enum		{ skipws=01,	
					/* skip whitespace on input */
			  left=02,  right=04, internal=010,
					/* padding location */
			  dec=020, oct=040, hex=0100, 
					/* conversion base */
			  showbase=0200, showpoint=0400, uppercase=01000,
			  showpos=02000, 
					/* modifiers */
			  scientific=04000, fixed=010000,
					/* floating point notation */
			  unitbuf=020000, stdio=040000
					/* stuff to control flushing */
			  } ;
	static const long 
			basefield ; /* dec|oct|hex */
	static const long
			adjustfield ; /* left|right|internal */
	static const long
			floatfield ; /* scientific|fixed */
public:
			ios(streambuf*) ;
	virtual		~ios() ;

	long		flags() const 	{ return x_flags ; }
	long		flags(long f);

	long		setf(long setbits, long field);
	long		setf(long) ;
	long		unsetf(long) ;

	int		width()	const	{ return x_width ; }
	int		width(int w)
	{
			int i = x_width ; x_width = w ; return i ;
	}
		
	ostream*	tie(ostream* s); 
	ostream*	tie()		{ return x_tie ; }
	char		fill(char) ;
	char		fill() const	{ return x_fill ; }
	int		precision(int) ;
	int		precision() const	{ return x_precision ; }

	int		rdstate() const	{ return state ; }
			operator void*()
				{
				if (state&(failbit|badbit|hardfail)) return 0 ;
				else return this ;
				}
                        operator const void*() const 
				{ 
				if (state&(failbit|badbit|hardfail)) return 0 ; 
				else return this ; 
				}

	int		operator!() const
				{ return state&(failbit|badbit|hardfail); } 
	int		eof() const	{ return state&eofbit; }
	int		fail() const	{ return state&(failbit|badbit|hardfail); }
	int		bad() const	{ return state&badbit ; }
	int		good() const	{ return state==0 ; }
	void		clear(int i =0) 
				{	
				state =  (i&0377) | (state&hardfail) ;
				ispecial = (ispecial&~0377) | state ; 
				ospecial = (ospecial&~0377) | state ; 
				}
	streambuf*	rdbuf() { return bp ;} 

public: /* Members related to user allocated bits and words */
	long &		iword(int) ;
	void* &		pword(int) ;
	static long	bitalloc() ;
	static int	xalloc() ;

private: /*** privates for implemting allocated bits and words */ 
	static long	nextbit ;
	static long	nextword ;
	
	int		nuser ;
	union ios_user_union*
			x_user ;
	int	uresize(int) ;
public: /* static member functions */
	static void	sync_with_stdio() ;
protected:
	enum 		{ skipping=01000, tied=02000 } ;
			/*** bits 0377 are reserved for userbits ***/
	streambuf*	bp;
	void		setstate(int b)
			{	state |= (b&0377) ;
				ispecial |= b&~skipping ;
				ispecial |= b ;
			}
	int		state;	
	int		ispecial;		
	int		ospecial;
	int		isfx_special;
	int		osfx_special;		
	int		delbuf;
	ostream*	x_tie;
	long 		x_flags;
	short		x_precision;
	char		x_fill;
	short 		x_width;

	static void	(*stdioflush)() ;

	void		init(streambuf*) ;
				/* Does the real work of a constructor */
			ios() ; /* No initialization at all. Needed by
				 * multiple inheritance versions */
	int		assign_private ;
				/* needed by with_assgn classes */
private:		
			ios(ios&) ; 
	void		operator=(ios&) ; 
public:   /* old stream package compatibility */
	int		skip(int i) ; 
};

class streambuf {
	short		alloc;	
	short		x_unbuf;
	char* 		x_base;	
	char*		x_pbase;
	char*		x_pptr;	
	char* 		x_epptr;
	char* 		x_gptr;
	char*		x_egptr;
	char*		x_eback;
	int		x_blen;	
    private:
			streambuf(streambuf&); /* Declared but not defined */
	void		operator=(streambuf&); /* Declared but not defined */
    public:
	void		dbp();
    protected:
	char*		base() 		{ return x_base ; }
	char*		pbase()		{ return x_pbase ; }
	char*		pptr() 		{ return x_pptr ; }
	char*		epptr() 	{ return x_epptr ; }
	char*		gptr() 		{ return x_gptr ; }
	char*		egptr() 	{ return x_egptr ; }
	char*		eback() 	{ return x_eback ; }
	char* 		ebuf()		{ return x_base+x_blen ; }
	int		blen() const	{ return x_blen; }
	void		setp(char*  p, char*  ep)
	{
		x_pbase=x_pptr=p ; x_epptr=ep ;
	}
	void		setg(char*  eb,char*  g, char*  eg)
	{
		x_eback=eb; x_gptr=g ; x_egptr=eg ;
	}
	void		pbump(int n) 
	{ 
		x_pptr+=n ;
	}

	void		gbump(int n) 
	{ 
		x_gptr+=n ;
		}

	void		setb(char* b, char* eb, int a = 0 )
	{
		if ( alloc && x_base ) delete[] x_base ;
		x_base = b ;
		x_blen= (eb>b) ? (eb-b) : 0 ;
		alloc = a ;
		}
	int		unbuffered() const	{ return x_unbuf; }
	void		unbuffered(int unb) { x_unbuf = (unb!=0)  ; }
	int		allocate()
	{
		if ( x_base== 0 && !unbuffered() ) return doallocate() ;
		else			  	 return 0 ;
	}
	virtual int 	doallocate();
    public : 
	virtual int	overflow(int c=EOF);
	virtual int	underflow();
	virtual int	pbackfail(int c);
	virtual int	sync();
	virtual streampos
			seekoff(streamoff,ios::seek_dir,int =ios::in|ios::out);
	virtual streampos
			seekpos(streampos, int =ios::in|ios::out) ;
	virtual int	xsputn(const char*  s,int n);
	virtual int	xsgetn(char*  s,int n);

	int		in_avail()
	{
		return x_gptr<x_egptr ? x_egptr-x_gptr : 0 ;
	}

	int		out_waiting() 
	{	
		if ( x_pptr ) return x_pptr-x_pbase ;
		else	      return 0 ; 
	}

	int		sgetc()
	{
		/***WARNING: sgetc does not bump the pointer ***/
		return (x_gptr>=x_egptr) ? underflow() : zapeof(*x_gptr);
	}
	int		snextc()
	{
		return (++x_gptr>=x_egptr)
				? x_snextc()
				: zapeof(*x_gptr);
	}
	int		sbumpc()
	{
		return  ( x_gptr>=x_egptr && underflow()==EOF ) 
				? EOF 
				: zapeof(*x_gptr++) ;
	}
	int		optim_in_avail()
	{
		return x_gptr<x_egptr ;
	}
	int		optim_sbumpc()
	{
		return  zapeof(*x_gptr++) ;
	}
	void		stossc()
	{
		if ( x_gptr < x_egptr || 
		     ( x_gptr >= x_egptr && underflow() != EOF ) )
		  x_gptr++;
	}

	int		sputbackc(char c)
	{
		if (x_gptr > x_eback ) {
			if ( *--x_gptr == c ) return zapeof(c) ;
			else 		      return zapeof(*x_gptr=c) ;
		} else {
			return pbackfail(c) ;
		}
	}

	int		sputc(int c)
	{
		return (x_pptr>=x_epptr) ? overflow(zapeof(c))
				      : zapeof(*x_pptr++=c);
	}
	int		sputn(const char*  s,int n)
	 {
		if ( n <= (x_epptr-x_pptr) ) {
			memcpy(x_pptr,s,n) ;
			pbump(n);
			return n ;
		} else {
			return xsputn(s,n) ;
		}
	}
	int		sgetn(char*  s,int n)
	{
		if ( n <= (x_egptr-x_gptr) ) {
			memcpy(s,x_gptr,n) ;
			gbump(n);
			return n ;
		} else {
			return xsgetn(s,n) ;
		}
	}
	virtual streambuf*
			setbuf(char*  p, int len) ;
   	streambuf*	setbuf(unsigned char*  p, int len) ;

	streambuf*	setbuf(char*  p, int len, int count) ;
				/* obsolete third argument */
  			/*** Constructors -- should be protected ***/
			streambuf() ;
			streambuf(char*  p, int l) ;

			streambuf(char*  p, int l,int c) ;
			/* 3 argument form is obsolete.
			 * Use strstreambuf.
			 */
	virtual		~streambuf() ;
	/* 
	   The function:
	      int streambuf::pptr_non_null()
	   was added by IBM to fix a problem in which a number of member
	   functions in class istream needed to check that the "pptr()"
	   was non-null. You are advised NOT to use this function in your 
	   code.
	*/
	int		pptr_non_null() { return x_pptr != 0; }
private:
	int		x_snextc() ;
};

class istream : virtual public ios {
public: /* Constructor */
			istream(streambuf*) ;
	virtual		~istream() ;
public:	
	int		ipfx(int noskipws=0)
			{	if ( noskipws?(ispecial&~skipping):ispecial) {
					return do_ipfx(noskipws) ;
				} else return 1 ;
			}

	/* 
	  FUNCTION void isfx() IS INTERNAL AND SHOULD NOT BE USED.
	*/
	void		isfx() { }  

	istream&	seekg(streampos p) ;
	istream&	seekg(streamoff o, ios::seek_dir d) ;
   	streampos	tellg() ; 
	istream&	operator>> (istream& (*f)(istream&))
			{	return (*f)(*this) ; }
	istream&	operator>> (ios& (*f)(ios&) ) ;
	istream&	operator>>(char*);
	istream&	operator>>(signed char*);
	istream&	operator>>(unsigned char*);
	istream&	operator>>(char& c)
			{	if ( !ispecial && bp->optim_in_avail() &&
				     bp->pptr_non_null() ) {
					c = bp->optim_sbumpc() ;
					return *this;
				}
				else {
					return (rs_complicated(c));
				}
			}
	istream&	operator>>(signed char& c)
			{	if ( !ispecial && bp->optim_in_avail() && 
				     bp->pptr_non_null() ) {
					c = bp->optim_sbumpc() ;
					return *this;
				}
				else {
					return (rs_complicated(c));
				}
			}
	istream&	operator>>(unsigned char& c)
			{	if ( !ispecial && bp->optim_in_avail() && 
				     bp->pptr_non_null() ) {
					c = bp->optim_sbumpc() ;
					return *this;
				}
				else {
					return (rs_complicated(c));
				}
			}

	/* 
	  FUNCTION istream &rs_complicated(char &) IS INTERNAL AND SHOULD
	  NOT BE USED.
	*/
	istream&	rs_complicated(char& c);

	/* 
	  FUNCTION istream &rs_complicated(signed char &) IS INTERNAL 
	  AND SHOULD NOT BE USED.
	*/
	istream&	rs_complicated(signed char& c);

	/* 
	  FUNCTION istream &rs_complicated(unsigned char &) IS INTERNAL
	  AND SHOULD NOT BE USED.
	*/ 
	istream&	rs_complicated(unsigned char& c);

	istream&	operator>>(short&);
	istream&	operator>>(int&);
	istream&	operator>>(long&);
#if defined(_LONG_LONG)
	istream&	operator>>(long long&);
#endif /* defined(_LONG_LONG)	*/
	istream&	operator>>(unsigned short&);
	istream&	operator>>(unsigned int&);
	istream&	operator>>(unsigned long&);
#if defined(_LONG_LONG)
	istream&	operator>>(unsigned long long&);
#endif /* defined(_LONG_LONG)	*/
	istream&	operator>>(float&);
	istream&	operator>>(double&);
	istream&	operator>>(long double&);
	istream&	operator>>(streambuf*);
	istream&	operator>>(wchar_t*);
	istream&	operator>>(wchar_t&);
	istream&	get(char* , int lim, char delim='\n');
	istream&	get(signed char* b,int lim, char delim='\n');
	istream&	get(unsigned char* b,int lim, char delim='\n');
	istream&	getline(char* b, int lim, char delim='\n');
	istream&	getline(signed char* b, int lim, char delim='\n');
	istream&	getline(unsigned char* b, int lim, char delim='\n');
	istream&	get(streambuf& sb, char delim ='\n');
	istream&	get(wchar_t&);

	/* 
	  FUNCTION istream &get_complicated(char &) IS INTERNAL AND SHOULD
	  NOT BE USED.
	*/
	istream&	get_complicated(char& c);

	/* 
	  FUNCTION istream &get_complicated(signed char &) IS INTERNAL
	  AND SHOULD NOT BE USED.
	*/
	istream&	get_complicated(signed char& c);

	/* 
	  FUNCTION istream &get_complicated(unsigned char &) IS INTERNAL
	  AND SHOULD NOT BE USED.
	*/
	istream&	get_complicated(unsigned char& c);

	istream&	get(char& c)
			{
				if ( !(ispecial & ~skipping) && bp->optim_in_avail() ) { 
					x_gcount = 1 ;
					c = bp->sbumpc() ;
					return *this;
				} else {
					return (get_complicated(c));
				}
			}
	istream&	get(signed char& c)
			{
				if ( !(ispecial & ~skipping) && bp->optim_in_avail() ) {
					x_gcount = 1 ;
					c = bp->sbumpc() ;
					return *this;
				} else {
					return (get_complicated(c));
				}
			}
	istream&	get(unsigned char& c)
			{
				if ( !(ispecial & ~skipping) && bp->optim_in_avail() ) {
					x_gcount = 1 ;
					c = bp->sbumpc() ;
					return *this;
				} else {
					return (get_complicated(c));
				}
			}
	int 		get()
			{
				int c ;
				if ( !ipfx(1) ) return EOF ;
				else {
					c = bp->sbumpc() ;
					if ( c == EOF ) setstate(eofbit) ;
					return c ;
					}
			}
	int		peek() 
			{
				if ( ipfx(-1) ) return bp->sgetc() ;
				else		return EOF ;

			}
	istream&	ignore(int n=1,int delim=EOF) ;
	istream&	read(char*  s,int n);
	istream&	read(signed char* s,int n) 
			{
				return read((char*)s,n) ;
			}
	istream&	read(unsigned char* s,int n) 
			{
				return read((char*)s,n) ;
			}
	int		gcount() ;
	istream&	putback(char c);
	int		sync()	{ return bp->sync() ; }
protected:  

	/* 
	  FUNCTION int do_ipfx(int) IS INTERNAL AND SHOULD NOT BE USED.
	*/
	int		do_ipfx(int noskipws) ;

	/* 
	  FUNCTION void eatwhite() IS INTERNAL AND SHOULD NOT BE USED.
	*/
	void		eatwhite() ;

			istream() ;
private: 
	int		x_gcount ;
	void 		xget(char*  c) ;
	int		inf_special_in(streambuf * nbp);
	int		nan_special_in(streambuf * nbp);
	wchar_t		getawc(int&c);

public: /*** Obsolete constructors, carried over from stream package ***/
	/*
	  YOU ARE ADVISED NOT TO USE THE OBSOLETE FUNCTIONS SINCE THEY
	  MAY BE REMOVED IN A FUTURE VERSION.
	*/
			istream(streambuf*, int sk, ostream* t=0) ;
				/* obsolete, set sk and tie
				 * via format state variables */
			istream(int size ,char*,int sk=1) ;
				/* obsolete, use strstream */
			istream(int fd,int sk=1, ostream* t=0) ;
				/* obsolete use fstream */
};

class ostream : virtual public ios {
public: /* Constructor */
			ostream(streambuf*) ;
	virtual		~ostream();
public:	
	int		opfx()	/* Output prefix */
			{	if ( ospecial )	return do_opfx() ;
				else		return 1 ;
			}

	void		osfx() 
			{	if ( osfx_special ) do_osfx() ; }

	ostream&	flush() ;
	ostream&	seekp(streampos p) ;
	ostream&	seekp(streamoff o, ios::seek_dir d) ;
 	streampos	tellp() ; 

	ostream&	put(char c)
	{
		if (ospecial || osfx_special) {
			return complicated_put(c);
		}
		else {
			if (  bp->sputc(c) == EOF )  {
				setstate(eofbit|failbit) ;
			}
			return *this ;
		}
	}

	/* 
	  FUNCTION ostream &complicated_put(char) IS INTERNAL AND SHOULD 
	  NOT BE USED.
	*/
	ostream&	complicated_put(char c);

	ostream&	operator<<(char c)
	{
		if (ospecial || osfx_special) {
			return ls_complicated(c);
		}
		else {
			if (  bp->sputc(c) == EOF )  {
				setstate(eofbit|failbit) ;
			}
			return *this ;
		}
	}

	ostream&	operator<<(signed char c) 
	{
		if (ospecial || osfx_special) {
			return ls_complicated(c);
		}
		else {
			if (  bp->sputc(c) == EOF )  {
				setstate(eofbit|failbit) ;
			}
			return *this ;
		}
	}

	ostream&	operator<<(unsigned char c) 
	{
		if (ospecial || osfx_special) {
			return ls_complicated(c);
		}
		else {
			if (  bp->sputc(c) == EOF )  {
				setstate(eofbit|failbit) ;
			}
			return *this ;
		}
	}

	/* 
	  FUNCTION ostream &ls_complicated(char) IS INTERNAL AND SHOULD 
	  NOT BE USED.
	*/
	ostream& 	ls_complicated(char);

	/* 
	  FUNCTION ostream &ls_complicated(signed char) IS INTERNAL AND 
	  SHOULD NOT BE USED.
	*/
	ostream& 	ls_complicated(signed char);

	/* 
	  FUNCTION ostream &ls_complicated(unsigned char) IS INTERNAL AND 
	  SHOULD NOT BE USED.
	*/
	ostream& 	ls_complicated(unsigned char);

	ostream&	operator<<(wchar_t);
	ostream&	operator<<(const wchar_t*);
	ostream&	operator<<(const char*);
	ostream&	operator<<(const signed char*);
	ostream&	operator<<(const unsigned char*);
	ostream&	operator<<(int a); 
	ostream&	operator<<(long);	
#if defined(_LONG_LONG)
	ostream&	operator<<(long long);	
#endif /* defined(_LONG_LONG)	*/
	ostream&	operator<<(double);
	ostream&	operator<<(long double);
	ostream&	operator<<(float);
	ostream&	operator<<(unsigned int a);
	ostream&	operator<<(unsigned long);
#if defined(_LONG_LONG)
	ostream&	operator<<(unsigned long long);	
#endif /* defined(_LONG_LONG)	*/
	ostream&	operator<<(const void*);
	ostream&	operator<<(streambuf*);
	ostream&	operator<<(short i) { return *this << (int)i ; }
	ostream&	operator<<(unsigned short i) 
			{ return *this << (int)i  ; }

	ostream&	operator<< (ostream& (*f)(ostream&))
			{ return (*f)(*this) ; }
	ostream&	operator<< (ios& (*f)(ios&) ) ;

	ostream&	write(const char*  s,int n)	
	{
		if ( !state ) {
			if ( bp->sputn(s,n) != n ) setstate(eofbit|failbit);
			}
		return *this ;
	}
	ostream&	write(const signed char* s, int n)
	{
		return write((const char*)s,n);
	}
	ostream&	write(const unsigned char* s, int n)
	{
		return write((const char*)s,n);
	}
protected: /* More ostream members */

	/* 
	  FUNCTION int do_opfx() IS INTERNAL AND SHOULD NOT BE USED.
	*/
	int		do_opfx() ;

	/* 
	  FUNCTION void do_osfx() IS INTERNAL AND SHOULD NOT BE USED.
	*/
	void		do_osfx() ;

			ostream() ;

public: /*** Obsolete constructors, carried over from stream package ***/
	/*
	  YOU ARE ADVISED NOT TO USE THE OBSOLETE FUNCTIONS SINCE THEY
	  MAY BE REMOVED IN A FUTURE VERSION.
	*/
			ostream(int fd) ;
				/* obsolete use fstream */
			ostream(int size ,char*) ;
				/* obsolete, use strstream */
/*
   Function:
	int		wchar_out(int, char *, int) ;
 
   has been added by IBM to support wchar_t.

   Functions:
	ostream& pad_complicated(char c)
	ostream& pad_complicated(signed char c)
	ostream& pad_complicated(unsigned char c)

   have been added by IBM.  They are now obsolete, but
   remain for library compatability reasons.
*/
private:
	int		wchar_out(int, char *, int) ;
	ostream&        pad_complicated(char c);
        ostream&        pad_complicated(signed char c);
        ostream&        pad_complicated(unsigned char c);
} ;

class iostream : public istream, public ostream {
public:
			iostream(streambuf*) ;
	virtual		~iostream() ;
protected:
			iostream() ;
	} ;

class istream_withassign : public istream {
public:
			istream_withassign() ;
	virtual		~istream_withassign() ;
	istream_withassign&	operator=(istream&) ;
	istream_withassign&	operator=(streambuf*) ;
} ;

class ostream_withassign : public ostream {
public:
			ostream_withassign() ;
	virtual		~ostream_withassign() ;
	ostream_withassign&	operator=(ostream&) ;
	ostream_withassign&	operator=(streambuf*) ;
} ;

class iostream_withassign : public iostream {
public:
			iostream_withassign() ;
	virtual		~iostream_withassign() ;
	iostream_withassign&	operator=(ios&) ;
	iostream_withassign&	operator=(streambuf*) ;
} ;

extern istream_withassign cin ;
extern ostream_withassign cout ;
extern ostream_withassign cerr ;
extern ostream_withassign clog ;

ios&		dec(ios&) ; 
ostream&	endl(ostream& i) ;
ostream&	ends(ostream& i) ;
ostream&	flush(ostream&) ;
ios&		hex(ios&) ;
ios&		oct(ios&) ; 
istream&	ws(istream&) ;

#endif
f (  k8 *  $          z52^5
                 ./usr/lpp/xlC/include/sys/time.h                 $          $          #ifndef __Cxx_sys_time_h__
#define __Cxx_sys_time_h__
struct timestruc_t;
#include </usr/include/sys/time.h>
extern "C" {
#ifdef _POWER
int gettimeofday(struct timeval*, void*);
#else
int gettimeofday(struct timeval*, struct timezone*);
#endif
int settimeofday(struct timeval*, struct timezone*);
int usleep (unsigned int);
struct itimerval;
int setitimer (int, const itimerval*, itimerval*);
int getitimer (int, itimerval*);
int nsleep (timestruc_t*, timestruc_t*);
}
#endif
ed ckb9 `  $          z55L3b5
         2        ./usr/lpp/xlC/include/complex.h          $          $          /*ident	"@(#)cls4:incl-master/const-headers/complex.h	1.3" */
/*******************************************************************************
 
C++ source for the C++ Language System, Release 3.0.  This product
is a new release of the original cfront developed in the computer
science research center of AT&T Bell Laboratories.

Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
Copyright (c) 1984, 1989, 1990 AT&T.  All Rights Reserved.

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
Laboratories, Inc.  The copyright notice above does not evidence
any actual or intended publication of such source code.

*******************************************************************************/

#ifndef COMPLEXH
#define COMPLEXH
 
#include <iostream.h>
#include <errno.h>
#include <math.h>

#ifndef DOMAIN
#define DOMAIN		1
#endif
#ifndef SING
#define SING		2
#endif
#ifndef OVERFLOW
#define OVERFLOW	3
#endif
#ifndef UNDERFLOW
#define UNDERFLOW	4
#endif
#ifndef TLOSS
#define TLOSS		5
#endif
#ifndef PLOSS
#define PLOSS		6
#endif
#ifndef M_E
#define M_E	2.7182818284590452354
#endif
#ifndef M_LOG2E
#define M_LOG2E	1.4426950408889634074
#endif
#ifndef M_LOG10E
#define M_LOG10E	0.43429448190325182765
#endif
#ifndef M_LN2
#define M_LN2	0.69314718055994530942
#endif
#ifndef M_LN10
#define M_LN10	2.30258509299404568402
#endif
#ifndef M_PI
#define M_PI	3.14159265358979323846
#endif
#ifndef M_PI_2
#define M_PI_2	1.57079632679489661923
#endif
#ifndef M_PI_4
#define M_PI_4	0.78539816339744830962
#endif
#ifndef M_1_PI
#define M_1_PI	0.31830988618379067154
#endif
#ifndef M_2_PI
#define M_2_PI	0.63661977236758134308
#endif
#ifndef M_2_SQRTPI
#define M_2_SQRTPI	1.12837916709551257390
#endif
#ifndef M_SQRT2
#define M_SQRT2	1.41421356237309504880
#endif
#ifndef M_SQRT1_2
#define M_SQRT1_2	0.70710678118654752440
#endif

class complex {
	double	re, im;
public:
	complex()	{ re=0.0; im=0.0; }
	complex(double r, double i = 0.0)	{ re=r; im=i; }
	 	
	friend	inline  double	real(const complex&);
	friend	inline  double	imag(const complex&);

	friend	double	abs(complex);
	friend  double  norm(complex);
	friend  double	arg(complex);
	friend  inline  complex conj(complex);
	friend  complex cos(complex);
	friend  complex cosh(complex);
	friend	complex exp(complex);
	friend  complex log(complex);
	friend  complex pow(double, complex);
	friend	complex pow(complex, int);
	friend	complex pow(complex, double);
	friend	complex pow(complex, complex);
	friend  complex	polar(double, double = 0);
	friend  complex sin(complex);
	friend  complex sinh(complex);
	friend	complex sqrt(complex);

	friend	inline  complex	operator+(complex, complex);
	friend	inline  complex	operator-(complex);
	friend	inline  complex operator-(complex, complex);
	friend	complex operator*(complex, complex);
	friend 	complex operator/(complex, complex);
	friend 	inline  int	operator==(complex, complex);
	friend 	inline  int	operator!=(complex, complex);
	
	void operator+=(complex);
	void operator-=(complex);
	void operator*=(complex);
	void operator/=(complex);
};

ostream& operator<<(ostream&, complex);
istream& operator>>(istream&, complex&);

inline double real(const complex& a)
{
	return a.re;
}

inline double imag(const complex& a)
{
	return a.im;
}

inline complex operator+(complex a1, complex a2) 
{
	return complex(a1.re+a2.re, a1.im+a2.im);
}

inline complex operator-(complex a1,complex a2) 
{
	return complex(a1.re-a2.re, a1.im-a2.im);
}

inline complex operator-(complex a) 
{
	return complex(-a.re, -a.im);
}

inline complex conj(complex a) 
{
	return complex(a.re, -a.im);
}

inline int operator==(complex a, complex b) 
{
	return (a.re==b.re && a.im==b.im);
}

inline int operator!=(complex a, complex b)
{
	return (a.re!=b.re || a.im!=b.im);
}

inline void complex::operator+=(complex a)
{
	re += a.re;
	im += a.im;
}

inline void complex::operator-=(complex a)
{
	re -= a.re;
	im -= a.im;
}


extern const complex complex_zero;

class c_exception
{
	int	type;
	char	*name;
	complex	arg1;
	complex	arg2;
	complex	retval;
public:

	c_exception( char *n, const complex& a1, const complex& a2 = complex_zero )
		: name(n), arg1(a1), arg2(a2), type(0) { }

	friend int complex_error( c_exception& );

	friend complex exp( complex );
	friend complex sinh( complex );
	friend complex cosh( complex );
	friend complex log( complex );	
};

#endif
comk^   $        W  z5͔3b5
           W      ./usr/lpp/xlC/include/curses.h           $          $          #ifndef _AIX32_CURSES
#define newterm32 ______newterm32
#define newwin	______newwin
#define subwin	______subwin
#define wgetch	______wgetch
#else // ndef _AIX32_CURSES
#ifndef MINICURSES
#define newterm	______newterm
#define newwin	______newwin
#define subwin	______subwin
#define wgetch	______wgetch
#else  // ndef MINICURSES
#define m_newterm ______m_newterm
#endif // else ndef MINICURSES
#endif // else ndef _AIX32_CURSES
#define newpad	______newpad

#include </usr/include/curses.h>

#undef newpad
#ifndef _AIX32_CURSES
# undef newterm32
# undef newwin
# undef subwin
# undef wgetch
extern "C" {
  WINDOW *newwin(int, int, int, int);
  WINDOW *subwin(WINDOW *, int, int, int, int);
  WINDOW *newpad(int, int);
  SCREEN *newterm32(char *,FILE *,FILE *);
  int wgetch(WINDOW *);
}
# ifndef newterm
#  define newterm newterm32
# endif
#else // ndef _AIX32_CURSES
# ifndef MINICURSES
#  undef newterm
#  undef newwin
#  undef subwin
#  undef wgetch
extern "C" {
   WINDOW *newwin(int, int, int, int);
   WINDOW *subwin(WINDOW *, int, int, int, int);
   WINDOW *newpad(int, int);
   SCREEN *newterm(char *, FILE *, FILE *);
   int wgetch(WINDOW *);
}
# else  // ndef MINICURSES
#  undef m_newterm
   extern "C" SCREEN *m_newterm(char *, FILE *, FILE *);
# endif // else ndef MINICURSES
#endif // else ndef _AIX32_CURSES

#ifdef NULL
#undef NULL
#define NULL 0
#endif
Mk   $        7   z5n5k5
           7       ./usr/lpp/xlC/include/sys/mount.h                $          $          /* /usr/include/mount.h file was removed in aix 4.1 */

k
) ewwin
# undef subwin
# undef wgetch
extern "C" {
  WINDOW *newwin(int, int, int, int);
  WINDOW *subwin(WINDOW *, int, int, int, int);
  WINDOW *newpad(int, int);
  SCREEN *newterm32(char *,FILE *,FILE *);
  int wgetch(WINDOW *);
}
# ifndef newterm