Building a simple C++ script compiler from Scintilla and CINT

/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * header file iostream.sut.h
 ************************************************************************
 * Description:
 *  Stub file for making iostream library Borland C++ old version
 ************************************************************************
 * Copyright(c) 1991~2002,  Masaharu Goto (MXJ02154@niftyserve.or.jp)
 *
 ************************************************************************/

#ifndef G__IOSTREAM_H
#define G__IOSTREAM_H

#ifndef __CINT__

#include <iostream.h>

#ifndef G__OLDIMPLEMENTATION1635
#include <fstream.h>
/********************************************************************
 * static variables for iostream redirection
 ********************************************************************/
static streambuf *G__store_cout;
static streambuf *G__store_cerr;
static streambuf *G__store_cin;
static ofstream  *G__redirected_cout;
static ofstream  *G__redirected_cerr;
static ifstream  *G__redirected_cin;
/********************************************************************
 * G__redirectcout
 ********************************************************************/
extern "C" void G__unredirectcout() {
  if(G__store_cout) {
    cout.rdbuf(G__store_cout);
    G__store_cout = 0;
  }
  if(G__redirected_cout) {
    delete G__redirected_cout;
    G__redirected_cout = 0;
  }
}
/********************************************************************
 * G__redirectcout
 ********************************************************************/
extern "C" void G__redirectcout(const char* filename) {
  G__unredirectcout();
  G__redirected_cout = new ofstream(filename,ios::app);
  G__store_cout = cout.rdbuf(G__redirected_cout->rdbuf()) ;
}
/********************************************************************
 * G__redirectcerr
 ********************************************************************/
extern "C" void G__unredirectcerr() {
  if(G__store_cerr) {
    cerr.rdbuf(G__store_cerr);
    G__store_cerr = 0;
  }
  if(G__redirected_cerr) {
    delete G__redirected_cerr;
    G__redirected_cerr = 0;
  }
}
/********************************************************************
 * G__redirectcerr
 ********************************************************************/
extern "C" void G__redirectcerr(const char* filename) {
  G__unredirectcerr();
  G__redirected_cerr = new ofstream(filename,ios::app);
  G__store_cerr = cerr.rdbuf(G__redirected_cerr->rdbuf()) ;
}
/********************************************************************
 * G__redirectcin
 ********************************************************************/
extern "C" void G__unredirectcin() {
  if(G__store_cin) {
    cin.rdbuf(G__store_cin);
    G__store_cin = 0;
  }
  if(G__redirected_cin) {
    delete G__redirected_cin;
    G__redirected_cin = 0;
  }
}
/********************************************************************
 * G__redirectcin
 ********************************************************************/
extern "C" void G__redirectcin(const char* filename) {
  G__unredirectcin();
  G__redirected_cin = new ifstream(filename,ios::in);
  G__store_cin = cin.rdbuf(G__redirected_cin->rdbuf()) ;
}
#endif /* 1635 */

#else

/********************************************************************
* macro G__MANIP_SUPPORT must be defined to enable true manipulator
*********************************************************************/
#define G__MANIP_SUPPORT

typedef long streampos ;
typedef long streamoff ;

class streambuf ;
class ostream ;

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, binary=0x80} ;
  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 */
                    , boolalpha = 100000 , adjustfield = 14
                    , basefield = 112 , floatfield = 6144
		    } ;
  // static const long basefield ; /* dec|oct|hex */
  // static const long adjustfield ; /* left|right|internal */
  // static const long floatfield ; /* scientific|fixed */

 protected:
  ios(streambuf*) ;
  virtual ~ios() ;

 public:
  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);
		
  ostream*	tie(ostream* s); 
  ostream*	tie();	
  char		fill(char) ;
  char		fill() const;
  int		precision(int) ;
  int		precision() const;

  int		rdstate() const;
  operator void*();
  // operator const void*() const;
  int	operator!() const;
  int		eof() const;
  int		fail() const;
  int		bad() const;
  int		good() const;
  void		clear(int i =0) ;
  streambuf*	rdbuf() ;

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 ;
  void	uresize(int) ;
public: /* static member functions */
  static void	sync_with_stdio() ;
protected:
  /* 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&) ; /* Declared but not defined */
  void		operator=(ios&) ; /* Declared but not defined */
 public:   /* old stream package compatibility */
#ifdef G__NEVER
  int		skip(int i) ; 
#endif
};

class streambuf {
 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);
  virtual int	do_sputn(const char*  s,int n);
  virtual int	do_sgetn(char*  s,int n);

  int		in_avail();
  int		out_waiting() ;
  int		sgetc();
  int		snextc();
  int		sbumpc();
  // int		optim_in_avail();
  // int		optim_sbumpc();
  void		stossc();
  int		sputbackc(char c);
  int		sputc(int c);
  int		sputn(const char*  s,int n);
  int		sgetn(char*  s,int 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 ***/
 protected:
  streambuf() ;
 private:
  streambuf(streambuf&) ;
 public:
  // streambuf(char*  p, int l) ;

  // streambuf(char*  p, int l,int c) ; 
  /* 3 argument form is obsolete.
   * Use strstreambuf.
   */
  virtual		~streambuf() ;
};

class istream : virtual public ios {
public: /* Constructor */
  istream(streambuf*) ;
  virtual	~istream() ;
public:	
  int		ipfx(int noskipws /* =0 */);
  void		isfx() { }  
#ifdef G__OLDIMPLEMENTATION762
  istream&	seekg(streampos p) ;
  istream&	seekg(streamoff o, ios::seek_dir d) ;
#endif
  streampos	tellg() ; 
#ifdef G__MANIP_SUPPORT
  istream&	operator>> (istream& (*f)(istream&));
  istream&	operator>> (ios& (*f)(ios&) ) ;
#endif
  istream&	operator>>(char*);
  istream&	operator>>(unsigned char*);
  istream&	operator>>(unsigned char& c);
  istream&	operator>>(char& c);
  // istream&	rs_complicated(unsigned char& c);
  // istream&	rs_complicated(char& c);
  istream&	operator>>(short&);
  istream&	operator>>(int&);
  istream&	operator>>(long&);
  istream&	operator>>(unsigned short&);
  istream&	operator>>(unsigned int&);
  istream&	operator>>(unsigned long&);
  istream&	operator>>(float&);
  istream&	operator>>(double&);
  istream&	operator>>(streambuf*);
  istream&	get(char* , 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(unsigned char* b, int lim, char delim='\n');
  istream&	get(streambuf& sb, char delim ='\n');
  // istream&	get_complicated(unsigned char& c);
  // istream&	get_complicated(char& c);
  istream&	get(unsigned char& c);
  istream&	get(char& c);
  int 		get();
  int		peek() ;
  istream&	ignore(int n=1,int delim=EOF) ;
  istream&	read(char*  s,int n);
  // istream&	read(unsigned char* s,int n) ;
  int		gcount() ;
  istream&	putback(char c);
  // int		sync();

protected:  
  istream() ;

public: /*** Obsolete constructors, carried over from stream package ***/
#ifdef G__NEVER
  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 */
#endif
};

class ostream : virtual public ios {
public: /* Constructor */
  ostream(streambuf*) ;
  virtual	~ostream();
public:	
  int		opfx();	/* Output prefix */
  void		osfx() ;

  ostream&	flush() ;
#ifdef G__OLDIMPLEMENTATION762
  ostream&	seekp(streampos p) ;
  ostream&	seekp(streamoff o, ios::seek_dir d) ;
#endif
  streampos	tellp() ; 
  ostream&	put(char c);
  // ostream&	complicated_put(char c);
  ostream&	operator<<(char c);
  ostream&	operator<<(unsigned char c) ;
  // ostream& 	ls_complicated(char);
  // ostream& 	ls_complicated(unsigned char);

  ostream&	operator<<(const char*);
  ostream&	operator<<(int a); 
  ostream&	operator<<(long);	
  ostream&	operator<<(double);
  ostream&	operator<<(float);
  ostream&	operator<<(unsigned int a);
  ostream&	operator<<(unsigned long);
  ostream&	operator<<(void*);
  /*	ostream&	operator<<(const void*);   add this later */
  ostream&	operator<<(streambuf*);
  ostream&	operator<<(short i); 
  ostream&	operator<<(unsigned short i) ;

#ifdef G__MANIP_SUPPORT
  ostream&	operator<< (ostream& (*f)(ostream&));
  ostream&	operator<< (ios& (*f)(ios&) ) ;
#endif

  ostream&	write(const char*  s,int n)	;
  // ostream&	write(const unsigned char* s, int n);

public: /*** Obsolete constructors, carried over from stream package ***/
#ifdef G__NEVER
  ostream(int fd) ; /* obsolete use fstream */
  ostream(int size ,char*) ; /* obsolete, use strstream */
#endif
} ;

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


extern istream cin ;
extern ostream cout ;
extern ostream cerr ;
extern ostream 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 /* __CINT__ */



#endif