Path: utzoo!utgpu!water!watmath!uunet!tut.cis.ohio-state.edu!BERKELEY.EDU!andreas%rio.Berkeley.EDU
From: andreas%rio.Berkeley.EDU@BERKELEY.EDU (Andreas Neyer)
Newsgroups: gnu.g++.bug
Subject: (none)
Message-ID: <8809300234.AA02031@rio>
Date: 30 Sep 88 02:34:43 GMT
Sender: daemon@tut.cis.ohio-state.edu
Distribution: gnu
Organization: GNUs Not Usenet
Lines: 3894

Hi,

I just installed version 1.27 of gcc and g++. 
Since I have never installed a large program
I ran some of the tests for g++lib.a. 
They compiled and ran o.k.
Trying to compile my own program I encountered the 
problem/bug described below. I'd like to know whether
this is a bug in g++, an error in installing g++ or
something else.


Thank you in advance for your response: 

			Andreas Neyer
                        andreas@united


* Typescript:

Script started on Wed Sep 28 16:18:12 1988

santropez:1> g++ -v -c -I$HOME/include System.c

g++ version 1.27.0
 echo use .cc filename extension!
use .cc filename extension!
 /usr/tools/lib/gcc-cpp+ -v -I/united1/users/others/andreas/include -undef -D__GNU__ -D__GNUG__ -Dmc68000 -Dsun -Dunix -D__HAVE_FPU__ -Dmc68020 System.c /tmp/cca06459.cpp
GNU CPP version 1.27.0
 /usr/tools/lib/gcc-c++ /tmp/cca06459.cpp -quiet -dumpbase System.c -version -o /tmp/cca06459.s
GNU C++ version 1.27.0 (68k, MIT syntax) compiled by GNU C version 1.27.
Failed assertion (0) at line 1569 of `search.c'.
g++: Program c++ got fatal signal 6.

santropez:2> g++ -E -I$HOME/include System.c > Systemn .e
System.e: File exists.
santropez:3> g++ -E -I$HOME/include System.c >! System.e
santropez:4> exit
santropez:5> 
script done on Wed Sep 28 16:22:04 1988


* Machine:	

sun3/75


* Operating System:

Sun UNIX 4.2 Release 3.4 (GENERIC) #15: Fri Mar 4 10:17:54 PST 1988


* Machine dependent include files:

tm.h:	tm-sun3+.h ( as in SUN3.README )
md:     m68k.md



* File System.e ( produced with -E option see typescript above ):
----------------------------------------------------------------------
// use .cc filename extension!
# 1 "System.c"
# 1 "/united1/users/others/andreas/include/System.h"



# 1 "/usr/tools/lib/g++-include/math.h"
 
 






























overload acos;
overload acosh;
overload asin;
overload asinh;
overload atan2;
overload atanh;
overload ceil;
overload cos;
overload cosh;
overload exp;
overload floor;
overload gamma;
overload hypot;
overload log;
overload log10;
overload pow;
overload sin;
overload sinh;
overload sqrt;
overload tan;
overload tanh;

extern double  acos  (double) asm ("_" "acos") ;
extern double  acosh  (double) asm ("_" "acosh") ;
extern double  asin  (double) asm ("_" "asin") ;
extern double  asinh  (double) asm ("_" "asinh") ;
extern double  atan  (double) asm ("_" "atan") ;
extern double  atan2  (double, double) asm ("_" "atan2") ;
extern double  atanh  (double) asm ("_" "atanh") ;
extern double  cbrt  (double) asm ("_" "cbrt") ;
extern double  ceil  (double) asm ("_" "ceil") ;
extern double  copysign  (double,double) asm ("_" "copysign") ;
extern double  cos  (double) asm ("_" "cos") ;
extern double  cosh  (double) asm ("_" "cosh") ;
extern double  drem  (double,double) asm ("_" "drem") ;
extern double  erf  (double) asm ("_" "erf") ;
extern double  erfc  (double) asm ("_" "erfc") ;
extern double  exp  (double) asm ("_" "exp") ;
extern double  expm1  (double) asm ("_" "expm1") ;
extern double  fabs  (double) asm ("_" "fabs") ;
extern double  finite  (double) asm ("_" "finite") ;
extern double  floor  (double) asm ("_" "floor") ;
extern double  frexp  (double, int*) asm ("_" "frexp") ;
extern double  gamma  (double) asm ("_" "gamma") ;
extern double  hypot  (double,double) asm ("_" "hypot") ;
extern double  infnan  (int) asm ("_" "infnan") ;
extern int     isinf  (double) asm ("_" "isinf") ;
extern int     isnan  (double) asm ("_" "isnan") ;
extern double  j0  (double) asm ("_" "j0") ;
extern double  j1  (double) asm ("_" "j1") ;
extern double  jn  (int, double) asm ("_" "jn") ;
extern double  ldexp  (double, int) asm ("_" "ldexp") ;
extern double  lgamma  (double) asm ("_" "lgamma") ;
extern double  log  (double) asm ("_" "log") ;
extern double  log10  (double) asm ("_" "log10") ;
extern double  log1p  (double) asm ("_" "log1p") ;
extern double  logb  (double) asm ("_" "logb") ;
extern double  modf  (double, double*) asm ("_" "modf") ;
extern double  pow  (double, double) asm ("_" "pow") ;
extern double  rint  (double) asm ("_" "rint") ;
extern double  scalb  (double, int) asm ("_" "scalb") ;
extern double  sin  (double) asm ("_" "sin") ;
extern double  sinh  (double) asm ("_" "sinh") ;
extern double  sqrt  (double) asm ("_" "sqrt") ;
extern double  tan  (double) asm ("_" "tan") ;
extern double  tanh  (double) asm ("_" "tanh") ;
extern double  y0  (double) asm ("_" "y0") ;
extern double  y1  (double) asm ("_" "y1") ;
extern double  yn  (int, double) asm ("_" "yn") ;

 

 


struct exception
{
  int type;
  char* name;
  double arg1, arg2, retval;
};








int matherr(exception*);



# 1 "/usr/tools/lib/g++-include/values.h"
 
 


























































 
# 75 "/usr/tools/lib/g++-include/values.h"









# 126 "/usr/tools/lib/g++-include/math.h"


 





 

















































# 4 "/united1/users/others/andreas/include/System.h"

# 1 "/usr/tools/lib/g++-include/String.h"
 
 

























# 1 "/usr/tools/lib/g++-include/stream.h"
 
 
























# 1 "/usr/tools/lib/g++-include/File.h"
 
 
























# 1 "/usr/tools/lib/g++-include/builtin.h"
 

 





















 








overload clearbit;
overload dec;
overload gcd;
overload hex;
overload lcm;
overload lg;
overload oct;
overload setbit;
overload sign;
overload sqr;
overload testbit;

# 1 "/usr/tools/lib/g++-include/std.h"
 
 































overload abs; 

extern void      _exit  (int) asm ("_" "_exit") ;
extern void      abort  () asm ("_" "abort") ;
extern int       abs  (int) asm ("_" "abs") ;
extern int       access  (const char*, int) asm ("_" "access") ;
extern int       acct  (const char*) asm ("_" "acct") ;
extern unsigned  alarm  (unsigned) asm ("_" "alarm") ;
extern void*     alloca  (int) asm ("_" "alloca") ;
extern double    atof  (const char*) asm ("_" "atof") ;
extern int       atoi  (const char*) asm ("_" "atoi") ;
extern long      atol  (const char*) asm ("_" "atol") ;
extern int       bcmp  (const void*, const void*, int) asm ("_" "bcmp") ;
extern int       bcopy  (const void*, void*, int) asm ("_" "bcopy") ;
extern void*     brk  (void*) asm ("_" "brk") ;
extern int       bzero  (void*, int) asm ("_" "bzero") ;
extern void*     calloc  (unsigned, unsigned) asm ("_" "calloc") ;
extern void      cfree  (void*) asm ("_" "cfree") ;
extern int       chdir  (const char*) asm ("_" "chdir") ;
extern int       chmod  (const char*, int) asm ("_" "chmod") ;
extern int       chown  (const char*, int, int) asm ("_" "chown") ;
extern long      clock  () asm ("_" "clock") ;
extern int       close  (int) asm ("_" "close") ;
extern int       creat  (const char*, int) asm ("_" "creat") ;
extern char*     crypt  (const char*, const char*) asm ("_" "crypt") ;
extern char*     ctermid  (char*) asm ("_" "ctermid") ;
extern char*     cuserid  (char*) asm ("_" "cuserid") ;
extern double    drand48  () asm ("_" "drand48") ;
extern int       dup  (int) asm ("_" "dup") ;
extern int       dup2  (int, int) asm ("_" "dup2") ;
extern int       dysize  (int) asm ("_" "dysize") ;
extern char*     ecvt  (double, int, int*, int*) asm ("_" "ecvt") ;
extern char*     encrypt  (char*, int) asm ("_" "encrypt") ;
extern double    erand  (short*) asm ("_" "erand") ;
extern int       execl  (const char*, const char *, ...) asm ("_" "execl") ;
extern int       execle  (const char*, const char *, ...) asm ("_" "execle") ;
extern int       execlp  (const char*, const char*, ...) asm ("_" "execlp") ;
extern int       exect  (const char*,  const char**,  char**) asm ("_" "exect") ;
extern int       execv  (const char*,  const char**) asm ("_" "execv") ;
extern int       execve  (const char*, const char**, char**) asm ("_" "execve") ;
extern int       execvp  (const char*,  const char**) asm ("_" "execvp") ;
extern void      exit  (int) asm ("_" "exit") ;
extern int       fchmod  (int, int) asm ("_" "fchmod") ;
extern int       fchown  (int, int, int) asm ("_" "fchown") ;
extern int       fcntl  (int, int, int) asm ("_" "fcntl") ;
extern char*     fcvt  (double, int, int*, int*) asm ("_" "fcvt") ;
extern int       ffs  (int) asm ("_" "ffs") ;
extern int       flock  (int, int) asm ("_" "flock") ;
extern int       fork  () asm ("_" "fork") ;
extern void      free  (void*) asm ("_" "free") ;
extern int       fsync  (int) asm ("_" "fsync") ;
extern long      ftok  (const char*, int) asm ("_" "ftok") ;
extern int       ftruncate  (int, unsigned long) asm ("_" "ftruncate") ;
extern char*     gcvt  (double, int, char*) asm ("_" "gcvt") ;
extern char*     getcwd  (char*, int) asm ("_" "getcwd") ;
extern int       getdomainname  (char*, int) asm ("_" "getdomainname") ;
extern int       getdtablesize  () asm ("_" "getdtablesize") ;
extern int       getegid  () asm ("_" "getegid") ;
extern char*     getenv  (const char*) asm ("_" "getenv") ;
extern int       geteuid  () asm ("_" "geteuid") ;
extern int       getgid  () asm ("_" "getgid") ;
extern int       getgroups  (int, int*) asm ("_" "getgroups") ;
extern long      gethostid  () asm ("_" "gethostid") ;
extern int       gethostname  (char*, int) asm ("_" "gethostname") ;
extern char*     getlogin  () asm ("_" "getlogin") ;
extern int       getopt  (int, char**, char*) asm ("_" "getopt") ;
extern int       getpagesize  () asm ("_" "getpagesize") ;
extern char*     getpass  (const char*) asm ("_" "getpass") ;
extern int       getpgrp  () asm ("_" "getpgrp") ;
extern int       getpid  () asm ("_" "getpid") ;
extern int       getppid  () asm ("_" "getppid") ;
extern int       getpriority  (int, int) asm ("_" "getpriority") ;
extern int       getpw  (int, char*) asm ("_" "getpw") ;
extern unsigned  getuid  () asm ("_" "getuid") ;
extern char*     getwd  (const char*) asm ("_" "getwd") ;
extern char*     index  (const char*, int) asm ("_" "index") ;
extern char*     initstate  (unsigned, char*, int) asm ("_" "initstate") ;
extern int       ioctl  (int, int, char*) asm ("_" "ioctl") ;
extern int       isatty  (int) asm ("_" "isatty") ;
extern long      jrand48  (short*) asm ("_" "jrand48") ;
extern int       kill  (int, int) asm ("_" "kill") ;
extern int       killpg  (int, int) asm ("_" "killpg") ;
extern void      lcong48  (short*) asm ("_" "lcong48") ;
extern int       link  (const char*, const char*) asm ("_" "link") ;
extern int       lock  (int, int, long) asm ("_" "lock") ;
extern long      lrand48  () asm ("_" "lrand48") ;
extern long      lseek  (int, long, int) asm ("_" "lseek") ;
extern void*     malloc  (unsigned) asm ("_" "malloc") ;
extern void*     memalign  (unsigned, unsigned) asm ("_" "memalign") ;
extern void*     memccpy  (void*, const void*, int, int) asm ("_" "memccpy") ;
extern void*     memchr  (const void*, int, int) asm ("_" "memchr") ;
extern int       memcmp  (const void*, const void*, int) asm ("_" "memcmp") ;
extern void*     memcpy  (void*, const void*, int) asm ("_" "memcpy") ;
extern void*     memset  (void*, int, int) asm ("_" "memset") ;
extern int       mkdir  (const char*, int) asm ("_" "mkdir") ;
extern int       mknod  (const char*, int, int) asm ("_" "mknod") ;
extern char*     mkstemp  (char*) asm ("_" "mkstemp") ;
extern char*     mktemp  (char*) asm ("_" "mktemp") ;
extern long      mrand48  () asm ("_" "mrand48") ;
extern int       nice  (int) asm ("_" "nice") ;
extern long      nrand48  (short*) asm ("_" "nrand48") ;
extern int       open  (const char*, int, ...) asm ("_" "open") ;
extern void      pause  () asm ("_" "pause") ;
extern void      perror  (const char*) asm ("_" "perror") ;
extern int       pipe   (int*) asm ("_" "pipe") ;
extern void      profil  (char*, int, int, int) asm ("_" "profil") ;
extern int       psignal  (unsigned, char*) asm ("_" "psignal") ;
extern int       ptrace  (int, int, int, int) asm ("_" "ptrace") ;
extern int       putenv  (const char*) asm ("_" "putenv") ;
extern int       rand  () asm ("_" "rand") ;
extern long      random  () asm ("_" "random") ;
extern int       read  (int, void*, unsigned) asm ("_" "read") ;
extern int       readlink  (const char*, char*, int) asm ("_" "readlink") ;
extern void*     realloc  (void*, unsigned) asm ("_" "realloc") ;
extern int       rename  (const char*, const char*) asm ("_" "rename") ;
extern char*     rindex  (const char*, int) asm ("_" "rindex") ;
extern int       rmdir  (const char*) asm ("_" "rmdir") ;               
extern void*     sbrk  (int) asm ("_" "sbrk") ;              
extern short*    seed48  (short*) asm ("_" "seed48") ;
extern int       send  (int, char*, int, int) asm ("_" "send") ;
extern int       setgid  (int) asm ("_" "setgid") ;
extern int       sethostname  (char*, int) asm ("_" "sethostname") ;
extern int       setkey  (const char*) asm ("_" "setkey") ;
extern int       setpgrp  (int, int) asm ("_" "setpgrp") ;
extern int       setpriority  (int, int, int) asm ("_" "setpriority") ;
extern int       setregid  (int, int) asm ("_" "setregid") ;
extern int       setreuid  (int, int) asm ("_" "setreuid") ;
extern char*     setstate  (char*) asm ("_" "setstate") ;
extern int       setuid  (int) asm ("_" "setuid") ;
extern int       sigblock  (int) asm ("_" "sigblock") ;
extern int       siginterrupt  (int, int) asm ("_" "siginterrupt") ;
extern int       sigpause  (int) asm ("_" "sigpause") ;
extern int       sigsetmask  (int) asm ("_" "sigsetmask") ;
extern unsigned  sleep  (unsigned) asm ("_" "sleep") ;
extern int       srand  (int) asm ("_" "srand") ;
extern void      srand48  (long) asm ("_" "srand48") ;
extern void      srandom  (int) asm ("_" "srandom") ;
extern int       stime  (long*) asm ("_" "stime") ;
extern char*     strcat  (char*, const char*) asm ("_" "strcat") ;
extern char*     strchr  (const char*, int) asm ("_" "strchr") ;
extern int       strcmp  (const char*, const char*) asm ("_" "strcmp") ;
extern char*     strcpy  (char*, const char*) asm ("_" "strcpy") ;
extern int       strcspn  (const char*, const char*) asm ("_" "strcspn") ;
extern char*     strdup  (const char*) asm ("_" "strdup") ;
extern int       strlen  (const char*) asm ("_" "strlen") ;
extern char*     strncat  (char*, const char*, int) asm ("_" "strncat") ;
extern int       strncmp  (const char*, const char*, int) asm ("_" "strncmp") ;
extern char*     strncpy  (char*, const char*, int) asm ("_" "strncpy") ;
extern char*     strpbrk  (const char*, const char*) asm ("_" "strpbrk") ;
extern char*     strrchr  (const char*, int) asm ("_" "strrchr") ;
extern int       strspn  (const char*, const char*) asm ("_" "strspn") ;
extern double    strtod  (const char*, char**) asm ("_" "strtod") ;
extern char*     strtok  (char*, const char*) asm ("_" "strtok") ;
extern long      strtol  (const char*, char**, int) asm ("_" "strtol") ;
extern void      swab  (void*, void*, int) asm ("_" "swab") ;
extern int       symlink  (const char*, const char*) asm ("_" "symlink") ;
extern int       syscall  (int, ...) asm ("_" "syscall") ;
extern int       system  (const char*) asm ("_" "system") ;
extern char*     tempnam  (char*, char*) asm ("_" "tempnam") ;
extern long      time  (long*) asm ("_" "time") ;
 
extern char*     tmpnam  (char*) asm ("_" "tmpnam") ;
extern int       truncate  (const char*, unsigned long) asm ("_" "truncate") ;
extern char*     ttyname  (int) asm ("_" "ttyname") ;
extern int       ttyslot  () asm ("_" "ttyslot") ;
extern unsigned  ualarm  (unsigned, unsigned) asm ("_" "ualarm") ;
extern long      ulimit  (int, long) asm ("_" "ulimit") ;
extern int       umask  (int) asm ("_" "umask") ;
extern int       unlink  (const char*) asm ("_" "unlink") ;
extern unsigned  usleep  (unsigned) asm ("_" "usleep") ;
extern int       vadvise  (int) asm ("_" "vadvise") ;
extern void*     valloc  (unsigned) asm ("_" "valloc") ;
extern int       vfork  () asm ("_" "vfork") ;
extern int       vhangup  () asm ("_" "vhangup") ;
extern int       wait  (int*) asm ("_" "wait") ;
extern int       write  (int, const void*, unsigned) asm ("_" "write") ;


extern char**   environ;
extern int      errno;
extern char*    sys_errlist[];
extern int      sys_nerr;                  
extern char*    optarg;
extern int      opterr;
extern int      optind;


# 46 "/usr/tools/lib/g++-include/builtin.h"

# 1 "/usr/tools/lib/g++-include/math.h"
 
 






















# 183 "/usr/tools/lib/g++-include/math.h"

# 47 "/usr/tools/lib/g++-include/builtin.h"


long         abs(long x);
double       abs(double x);
void         clearbit(long& x, long b);
void         setbit(long& x, long b);
int          testbit(long x, long b);
int          even(long y);
long         gcd(long x, long y);
long         lg(long x); 
long         lcm(long x, long y);
int          odd(long y);
double       pow(double x, long p);
long         pow(long x, long y);
int          sign(long x);
int          sign(double x);
long         sqr(long x);
double       sqr(double x);
long         sqrt(long y);

char*        itoa(long x, int base = 10, int width = 0);
char*        hex(long x, int width = 0);
char*        oct(long x, int width = 0);
char*        dec(long x, int width = 0);
char*        form(const char* fmt ...);

unsigned int hashpjw(const char*);
unsigned int multiplicativehash(int);
unsigned int foldhash(double);

 

inline double abs(double x) 
{
  return (x < 0.0)? -x : x;
}

inline long abs(long x) 
{
  return (x < 0)? -x : x;
}

inline int sign(long x)
{
  return (x == 0) ? 0 : ( (x > 0) ? 1 : -1 );
}

inline int sign(double x)
{
  return (x == 0.0) ? 0 : ( (x > 0.0) ? 1 : -1 );
}

inline long sqr(long x)
{
  return x * x;
}

inline double sqr(double x)
{
  return x * x;
}

inline int even(long y)
{
  return !(y & 1);
}

inline int odd(long y)
{
  return (y & 1);
}

inline long lcm(long x, long y)
{
  return x / gcd(x, y) * y;
}

inline void setbit(long& x, long b)
{
  x |= (1 << b);
}

inline void clearbit(long& x, long b)
{
  x &= ~(1 << b);
}

inline int testbit(long x, long b)
{
  return ((x & (1 << b)) != 0);
}

 


# 27 "/usr/tools/lib/g++-include/File.h"

# 1 "/usr/tools/lib/g++-include/stdio.h"
 
 





















 




























 



 


extern  struct  _iobuf {
    int      _cnt;
    char*    _ptr;
    char*    _base;

    int     _bufsiz;
    short   _flag;



    char    _file;
} _iob[];



































extern int    _doprnt(const char*, void*,     struct _iobuf *);
extern int    _doscan(    struct _iobuf *, const char*, void*);
extern int    _filbuf(    struct _iobuf *);
extern int    _flsbuf(unsigned,     struct _iobuf *);
extern int    fclose(    struct _iobuf *);
extern     struct _iobuf *  fdopen(int, const char*);
extern int    fflush(    struct _iobuf *);
extern int    fgetc(    struct _iobuf *);
extern char*  fgets(char*, int,     struct _iobuf  *);
extern     struct _iobuf *  fopen(const char*, const char*);
extern int    fprintf(    struct _iobuf *, const char* ...);
extern int    fputc(int,     struct _iobuf *);
extern int    fputs(const char*,     struct _iobuf *);
extern int    fread(void*, int, int,     struct _iobuf *);
extern     struct _iobuf *  freopen(const char*, const char*,     struct _iobuf *);
extern int    fscanf(    struct _iobuf *, const char* ...);
extern int    fseek(    struct _iobuf *, long, int);
extern long   ftell(    struct _iobuf  *);
extern int    fwrite(const void*, int, int,     struct _iobuf *);
extern char*  gets(char*);
extern int    getw(    struct _iobuf *);
extern int    pclose(    struct _iobuf *);
extern     struct _iobuf *  popen(const char*, const char*);
extern int    printf(const char* ...);
extern void   puts(const char*);
extern int    putw(int,     struct _iobuf *);
extern int    scanf(const char* ...);
extern void   setbuf(    struct _iobuf *, char*);
extern void   setbuffer(    struct _iobuf *, char*, int);
extern void   setlinebuf(    struct _iobuf *);
extern void   setvbuf(    struct _iobuf *, char*, int, int);
extern int    sscanf(char*, const char* ...);
extern     struct _iobuf *  tmpfile();
extern int    ungetc(int,     struct _iobuf *);
extern int    vfprintf(    struct _iobuf *, const char*, void* ap);
extern int    vprintf(const char*, void* ap);
extern int    vsprintf(char*, const char*, void* ap);


extern int    sprintf(char*, const char* ...);





# 28 "/usr/tools/lib/g++-include/File.h"

# 1 "/usr/tools/lib/g++-include/stddef.h"
 
 



























enum bool   
{           
  FALSE = 0,
  TRUE  = 1              
};





















typedef void (*one_arg_error_handler_t)(char*);


# 29 "/usr/tools/lib/g++-include/File.h"


enum io_mode                     
{
  io_readonly   = 0,            
  io_writeonly  = 1,
  io_readwrite  = 2, 
  io_appendonly = 3,
  io_append     = 4,             
};

enum access_mode                 
{
  a_createonly  = 0,             
  a_create      = 1,             
  a_useonly     = 2,             
  a_use         = 3,             
};

enum state_value                 
{ 
  _good         = 0,             
  _eof          = 1,             
  _fail         = 2,             
  _bad          = 4              
};


class File
{
protected:
      struct _iobuf *         fp;               
  char*         nm;               
  char          rw;               
  state_value   state;            
  long          stat;             

  void          initialize();
  void          reinitialize(const char*);
  void          check_state();

public:
                File();
                File(const char* filename, io_mode m, access_mode a);
                File(const char* filename, const char* m);   
                File(int filedesc, io_mode m);
                File(    struct _iobuf * fileptr);

                ~File();

 

  File&         open(const char* filename, io_mode m, access_mode a);
  File&         open(const char* filename, const char* m);
  File&         open(int  filedesc, io_mode m);
  File&         open(    struct _iobuf * fileptr);

  File&         close();
  File&         remove();

 

  int           filedesc();
  const char*   name();
  void          setname(const char* newname);
  int           iocount();

  int           rdstate();
  int           eof();
  int           fail();
  int           bad();
  int           good();

 

  int           readable();
  int           writable();
  int           is_open();

  void*         operator void*();

 

  void          error();
  void          clear(state_value f = 0);  
  File&         failif(int cond);

 

  File&         get(char& c);
  File&         put(char  c);
  File&         unget(char c);
  File&         putback(char c);  

 

  File&         put(const char* s);
  File&         get    (char* s, int n, char terminator = '\n');
  File&         getline(char* s, int n, char terminator = '\n');

 

  File&         read(void* x, int sz, int n);
  File&         write(void* x, int sz, int n);


 

  File&         seek(long pos, int seek_mode=0);  
  long          tell();

  File&         flush();
  File&         setbuf(int buffer_kind);  
  File&         setbuf(int size, char* buf);
  File&         raw();
};


 

extern void  verbose_File_error_handler(char*);
extern void  quiet_File_error_handler(char*);
extern void  fatal_File_error_handler(char*);
extern one_arg_error_handler_t File_error_handler;

extern  one_arg_error_handler_t 
             set_File_error_handler(one_arg_error_handler_t f);

 

inline int File::filedesc()
{ 
  return   ((fp)->_file) ;
}

inline const char* File::name()
{ 
  return nm; 
}

inline int File::rdstate()
{ 
  check_state();  return state;  
}                                

inline void* File::operator void*()
{ 
  return (state & (_bad|_fail))? 0 : this ; 
}

inline int File::eof()
{ 
  check_state(); return state & _eof; 
}

inline int File::fail()
{ 
  check_state(); return state & _fail; 
}

inline int File::bad()
{ 
  check_state(); return state & _bad; 
}

inline int File::good()
{ 
  check_state(); return rdstate() == _good; 
}

inline int File::iocount()
{ 
  return stat; 
}

inline int File::readable()
{ 
  return ((rw & 01) && (state & (_fail|_bad)) == 0);
}

inline int File::writable()
{ 
  return ((rw & 02) && (state & (_fail|_bad)) == 0);
}


inline int File::is_open()
{ 
  return (fp != 0);
}

inline void File::clear(state_value flag = 0)
{ 
  state = flag;
}

inline File& File::raw()
{ 
  return File::setbuf(   00004 ); 
}

 


# 27 "/usr/tools/lib/g++-include/stream.h"


class whitespace                 
{                                
  char filler;                     
};

class ostream: File
{
public:
           File::open;      File::close;
           File::remove;    File::filedesc;  File::is_open;
           File::raw;       File::put;       
           File::iocount;   File::error;     File::name;
           File::setname;   File::rdstate;   File::flush;
           File::eof;       File::fail;      File::bad;
           File::good;      File::clear;     File::failif;
           File::setbuf;    File::writable;  File::readable;
           

           ostream();
           ostream(const char* filename, io_mode m, access_mode a);
           ostream(const char* filename, const char* m);
           ostream(int filedesc, io_mode m = io_writeonly);
           ostream(    struct _iobuf * fileptr);

           ~ostream();

  void*    operator void*();

  ostream& form(const char* fmt, ...);           

  ostream& operator << (char   c);
  ostream& operator << (short  n);
  ostream& operator << (unsigned short n);
  ostream& operator << (int    n);
  ostream& operator << (unsigned int n);
  ostream& operator << (long   n);
  ostream& operator << (unsigned long n);
  ostream& operator << (float  n);
  ostream& operator << (double n);
  ostream& operator << (const char* s);
};


class istream: File
{
  ostream* tied_to;         
  void     _flush();

public:
           File::open;      File::close;     File::get;
           File::remove;    File::filedesc;  File::is_open;
           File::raw;       File::unget;     File::getline;
           File::iocount;   File::error;     File::name;
           File::setname;   File::rdstate;   File::putback;
           File::eof;       File::fail;      File::bad;
           File::good;      File::clear;     File::failif;
           File::setbuf;    File::writable;  File::readable;


           istream();
           istream(const char* filename, io_mode m, access_mode a);
           istream(const char* filename, const char* m);
           istream(int filedesc, io_mode m = io_readonly);
           istream(    struct _iobuf * fileptr);

           ~istream();

  void*    operator void*();

  ostream* tie(ostream* s);

  istream& scan(const char* fmt, ...);

  istream& operator >> (char&   c);
  istream& operator >> (short&  n);
  istream& operator >> (unsigned short& n);
  istream& operator >> (int&    n);
  istream& operator >> (unsigned int& n);
  istream& operator >> (long&   n);
  istream& operator >> (unsigned long& n);
  istream& operator >> (float&  n);
  istream& operator >> (double& n);
  istream& operator >> (char*   s);
  istream& operator >> (whitespace& w);
};

void eatwhite(istream& s);


 

extern istream  cin;              
extern ostream  cout;             
extern ostream  cerr;             

extern whitespace WS;             

 


inline void* ostream::operator void*()
{ 
  return (state & (_bad|_fail))? 0 : this ; 
}

inline ostream& ostream::operator<<(char   c)
{ 
  put(c);
  return *this;
}

inline ostream& ostream::operator<<(short  n)
{ 
  return form("%d",(int)n);
}

inline ostream& ostream::operator<<(unsigned short n)
{ 
  return form("%u",(unsigned)n);
}

inline ostream& ostream::operator<<(int    n)
{ 
  return form("%d",n);
}

inline ostream& ostream::operator<<(unsigned int n)
{ 
  return form("%u",n);
}

inline ostream& ostream::operator<<(long   n)
{ 
  return form("%ld",n);
}

inline ostream& ostream::operator<<(unsigned long n)
{ 
  return form("%lu",n);
}

inline ostream& ostream::operator<<(float  n)
{ 
  return form("%g",(double)n);
}

inline ostream& ostream::operator<<(double n)
{ 
  return form("%g",n);
}

inline ostream& ostream::operator<<(const char* s)
{ 
  put(s);
  return *this;
}

inline void*    istream::operator void*()
{ 
  return (state & (_bad|_fail))? 0 : this ; 
}

inline istream& istream::operator>>(char&   c)
{ 
  _flush();
  get(c);
  return *this;
}

inline istream& istream::operator>>(short&  n)
{ 
  return scan("%hd", &n); 
}

inline istream& istream::operator>>(unsigned short& n)
{ 
  return scan("%hd", &n); 
}

inline istream& istream::operator>>(int&    n)
{ 
  return scan("%d",  &n); 
}

inline istream& istream::operator>>(unsigned int& n)
{ 
  return scan("%d",  &n); 
}

inline istream& istream::operator>>(long&   n)
{ 
  return scan("%ld", &n); 
}

inline istream& istream::operator>>(unsigned long& n)
{ 
  return scan("%ld", &n); 
}

inline istream& istream::operator>>(float&  n)
{ 
  return scan("%f",  &n); 
}

inline istream& istream::operator>>(double& n)
{ 
  return scan("%lf", &n); 
}

inline istream& istream::operator>>(char*   s)
{ 
  return scan("%s",   s); 
}

 


# 28 "/usr/tools/lib/g++-include/String.h"


struct _Srep                      
{
  unsigned short    len;          
  unsigned short    sz;           
  short             ref;          
  char              s[1];         
                                  
                                  
};


class String;
class SubString;


struct re_pattern_buffer;        
struct re_registers;

class Regex
{
  friend class       String;
  friend class       SubString;

  re_pattern_buffer* buf;
  re_registers*      reg;

  void               initialize(const char* t, int tlen, int fast, 
                                int bufsize, const char* transtable);

public:
                     Regex(const char* t, 
                           int fast = 0, 
                           int bufsize = 40, 
                           const char* transtable = 0);

                     Regex(String& x, 
                           int fast = 0, 
                           int bufsize = 40, 
                           const char* transtable = 0);

                     ~Regex();

  int                match(const char* s, int len, int pos = 0);
  int                search(const char* s, int len, 
                            int& matchlen, int startpos = 0);
};


class SubString
{
  friend class      String;

  String*           S;
  unsigned short    pos;
  unsigned short    len;

  void              assign(_Srep*, const char*, int = -1);
                    SubString(String* x, int p, int l);
                    SubString(SubString& x);

public:
                    ~SubString();

  void              operator =  (String&     y);
  void              operator =  (SubString&  y);
  void              operator =  (const char* t);
  void              operator =  (char        c);
  
  friend String     operator +  (SubString& x, String&     y);
  friend String     operator +  (String&    x, SubString&  y);
  friend String     operator +  (SubString& x, SubString&  y);
  friend String     operator +  (SubString& x, const char* t);
  friend String     operator +  (SubString& x, char        c);

  friend int        operator == (SubString& x, String&     y);
  friend int        operator == (String&    x, SubString&  y);
  friend int        operator == (SubString& x, SubString&  y);
  friend int        operator == (SubString& x, const char* t);
  
  friend int        operator != (SubString& x, String&     y);
  friend int        operator != (String&    x, SubString&  y);
  friend int        operator != (SubString& x, SubString&  y);
  friend int        operator != (SubString& x, const char* t);
  
  friend int        operator <= (SubString& x, String&     y);
  friend int        operator <= (String&    x, SubString&  y);
  friend int        operator <= (SubString& x, SubString&  y);
  friend int        operator <= (SubString& x, const char* t);
  
  friend int        operator <  (SubString& x, String&     y);
  friend int        operator <  (String&    x, SubString&  y);
  friend int        operator <  (SubString& x, SubString&  y);
  friend int        operator <  (SubString& x, const char* t);
  
  friend int        operator >= (SubString& x, String&     y);
  friend int        operator >= (String&    x, SubString&  y);
  friend int        operator >= (SubString& x, SubString&  y);
  friend int        operator >= (SubString& x, const char* t);
  
  friend int        operator >  (SubString& x, String&     y);
  friend int        operator >  (String&    x, SubString&  y);
  friend int        operator >  (SubString& x, SubString&  y);
  friend int        operator >  (SubString& x, const char* t);

  int               contains(char        c);
  int               contains(String&     y);
  int               contains(SubString&  y);
  int               contains(const char* t);
  int               contains(Regex&       r);

  int               matches(Regex&  r);

 

  int               length();
  int               empty();
  const char*       operator char*();

  friend ostream&   operator<<(ostream& s, SubString& x);

 

  friend int        compare(SubString& x, String&     y);
  friend int        compare(String&    x, SubString&  y);
  friend int        compare(SubString& x, SubString&  y);
  friend int        compare(SubString& x, const char* y);

  friend void       concat(SubString&  x, String&     y, String& result);
  friend void       concat(SubString&  x, SubString&  y, String& result);
  friend void       concat(SubString&  x, const char* y, String& result);
  friend void       concat(SubString&  x, char        y, String& result);
  friend void       concat(String&     x, SubString&  y, String& result);
};


class String
{
  friend class      SubString;
  friend class      Regex;

  _Srep*            rep;

  int               search(int, int, const char*, int = -1);
  int               search(int, int, char);
  int               match(int, int, int, const char*, int = -1);
  void              _gsub(const char*, int, const char* ,int);
  void              _gsub(Regex&, const char*, int);

public:

 

                    String();
                    String(String&     x);
                    String(SubString&  x);
                    String(const char* t);
                    String(const char* t, int len);
                    String(char c);

                    ~String();

  String&           operator =  (String&     y);
  String&           operator =  (const char* y);
  String&           operator =  (char        c);
  String&           operator =  (SubString&  y);

 

  friend String     operator +  (String& x, String&     y);     
  friend String     operator +  (String& x, const char* t);
  friend String     operator +  (String& x, char        c);
  friend String     operator +  (String& x, SubString&  y);     
  friend String     operator +  (SubString& x, String&  y);     

  String&           operator += (String&     y);
  String&           operator += (SubString&  y);
  String&           operator += (const char* t);
  String&           operator += (char        c);

 

  friend int        operator == (String&     x, String&     y);
  friend int        operator == (String&     x, const char* t);
  friend int        operator == (String&     x, SubString&  y);
  friend int        operator == (SubString&  x, String&     y);
  
  friend int        operator != (String&     x, String&     y);
  friend int        operator != (String&     x, const char* t);
  friend int        operator != (String&     x, SubString&  y);
  friend int        operator != (SubString&  x, String&     y);
  
  friend int        operator <= (String&     x, String&     y);
  friend int        operator <= (String&     x, const char* t);
  friend int        operator <= (String&     x, SubString&  y);
  friend int        operator <= (SubString&  x, String&     y);
  
  friend int        operator <  (String&     x, String&     y);
  friend int        operator <  (String&     x, const char* t);
  friend int        operator <  (String&     x, SubString&  y);
  friend int        operator <  (SubString&  x, String&     y);
  
  friend int        operator >= (String&     x, String&     y);
  friend int        operator >= (String&     x, const char* t);
  friend int        operator >= (String&     x, SubString&  y);
  friend int        operator >= (SubString&  x, String&     y);
  
  friend int        operator >  (String&     x, String&     y);
  friend int        operator >  (String&     x, const char* t);
  friend int        operator >  (String&     x, SubString&  y);
  friend int        operator >  (SubString&  x, String&     y);

  friend int        fcompare(String&   x, String&     y);  

 

  int               index(char        c, int startpos = 0);      
  int               index(String&     y, int startpos = 0);      
  int               index(SubString&  y, int startpos = 0);      
  int               index(const char* t, int startpos = 0);  
  int               index(Regex&      r, int startpos = 0);       

  int               contains(char        c);
  int               contains(String&     y);
  int               contains(SubString&  y);
  int               contains(const char* t);
  int               contains(Regex&      r);

  int               contains(char        c, int pos);
  int               contains(String&     y, int pos);
  int               contains(SubString&  y, int pos);
  int               contains(const char* t, int pos);
  int               contains(Regex&      r, int pos);

  int               matches(char        c, int pos = 0);
  int               matches(String&     y, int pos = 0);
  int               matches(SubString&  y, int pos = 0);
  int               matches(const char* t, int pos = 0);
  int               matches(Regex&      r, int pos = 0);

 

  SubString         at(int         pos, int len);
  SubString         at(String&     x, int startpos = 0); 
  SubString         at(SubString&  x, int startpos = 0); 
  SubString         at(const char* t, int startpos = 0);
  SubString         at(char        c, int startpos = 0);
  SubString         at(Regex&      r, int startpos = 0); 

  SubString         before(int          pos);
  SubString         before(String&      x, int startpos = 0);
  SubString         before(SubString&   x, int startpos = 0);
  SubString         before(const char*  t, int startpos = 0);
  SubString         before(char         c, int startpos = 0);
  SubString         before(Regex&       r, int startpos = 0);

  SubString         after(int         pos);
  SubString         after(String&     x, int startpos = 0);
  SubString         after(SubString&  x, int startpos = 0);
  SubString         after(const char* t, int startpos = 0);
  SubString         after(char        c, int startpos = 0);
  SubString         after(Regex&      r, int startpos = 0);

 

  void              del(int         pos, int len);
  void              del(String&     y, int startpos = 0);
  void              del(SubString&  y, int startpos = 0);
  void              del(const char* t, int startpos = 0);
  void              del(char        c, int startpos = 0);
  void              del(Regex&      r, int startpos = 0);

  void              gsub(String&     pat, String&     repl);
  void              gsub(SubString&  pat, String&     repl);
  void              gsub(const char* pat, String&     repl);
  void              gsub(const char* pat, const char* repl);
  void              gsub(Regex&      pat, String&     repl);

 

  friend int        decompose(String& x, String& l, String& m, String& r,
                              Regex& pat, int startpos = 0);

  friend int        split(String& x, String res[], int maxn, String& sep);
  friend int        split(String& x, String res[], int maxn, Regex&  sep);

  friend String     join(String src[], int n, String& sep);

  friend String     replicate(char        c, int n);
  friend String     replicate(String&     y, int n);

  friend String     common_prefix(String& x, String& y, int startpos = 0);
  friend String     common_suffix(String& x, String& y, int startpos = -1);

  friend String     reverse(String& x);
  friend String     upcase(String& x);
  friend String     downcase(String& x);
  friend String     capitalize(String& x);

 

  void              reverse();
  void              upcase();
  void              downcase();
  void              capitalize();

 

  char              operator [] (int i);
  const char*       operator char*();

 

  friend ostream&   operator<<(ostream& s, String& x);
  friend ostream&   operator<<(ostream& s, SubString& x);
  friend istream&   operator>>(istream& s, String& x);

 

  int               length();
  int               empty();
  int               operator ! ();
  void              make_unique();
  void              setlength(int l);
  void              error(char* msg);

 

  friend int        compare(String&    x, String&     y);
  friend int        compare(String&    x, SubString&  y);
  friend int        compare(String&    x, const char* y);
  friend int        compare(SubString& x, String&     y);

  friend void       concat(String&    x, String&     y, String& result);
  friend void       concat(String&    x, SubString&  y, String& result);
  friend void       concat(SubString& x, String&     y, String& result);
  friend void       concat(String&    x, const char* y, String& result);
  friend void       concat(String&    x, char        y, String& result);

  void              copy(const char* y, int len = -1);
  void              copy(String& y);
  void              copy(SubString& y);
  void              copy(char y);
};



 

extern Regex RXwhite;           
extern Regex RXint;             
extern Regex RXdouble;          
                                
                                
extern Regex RXalpha;           
extern Regex RXlowercase;       
extern Regex RXuppercase;       
extern Regex RXalphanum;        
extern Regex RXidentifier;      


extern void default_String_error_handler(char*);
extern one_arg_error_handler_t String_error_handler;

extern one_arg_error_handler_t 
        set_String_error_handler(one_arg_error_handler_t f);

 


extern _Srep  _nil_Srep;

inline String::String()
{ 
  rep = &_nil_Srep;
}

inline String::String(String& x)
{ 
  rep = x.rep; if (rep->ref > 0) rep->ref++;
}

inline String::String(const char* t)
{
  rep = &_nil_Srep; copy(t);
}

inline String::String(const char* t, int tlen)
{
  rep = &_nil_Srep; copy(t, tlen);
}

inline String::String(SubString& y)
{
  rep = &_nil_Srep; copy(&(y.S->rep->s[y.pos]), y.len);
}

inline String::String(char c)
{
  rep = &_nil_Srep; char ch = c; copy(&ch, 1);
}

inline String::~String()
{ 
  if (rep->ref > 0 && --rep->ref == 0) delete rep;
}

inline String& String::operator =  (String& y)
{ 
  y.rep->ref++;
  if (rep->ref > 0 && --rep->ref == 0) delete rep;
  rep = y.rep;
  return *this; 
}

inline String& String::operator=(const char* t)
{
  copy(t); return *this;
}

inline String& String::operator=(SubString&  y)
{
  copy(&(y.S->rep->s[y.pos]), y.len); return *this;
}

inline String& String::operator=(char c)
{
  char ch = c;  copy(&ch, 1); return *this;
}


inline void String::copy(char c)
{
  char ch = c; copy(&ch, 1);
}

inline void String::copy(String& y)
{
  copy(y.rep->s, y.rep->len);
}

inline void String::copy(SubString& y)
{
  copy(&(y.S->rep->s[y.pos]), y.len);
}

inline SubString::SubString(SubString& x)
{ 
  S = x.S; pos = x.pos;   len = x.len; 
}

inline SubString::~SubString() {}


inline void SubString::operator = (const char* ys)
{
  assign(0, ys);
}

inline void SubString::operator = (char ch)
{
  assign(0, &ch, 1);
}

inline void SubString::operator = (String& y)
{
  assign(y.rep, y.rep->s, y.rep->len);
}

inline void SubString::operator = (SubString& y)
{
  assign(y.S->rep, &(y.S->rep->s[y.pos]), y.len);
}

inline String& String::operator+=(String& y)
{
  concat(*this, y, *this); return *this;
}

inline String& String::operator+=(SubString&  y)
{
  concat(*this, y, *this); return *this;
}

inline String& String::operator+=(const char* t)
{
  concat(*this, t, *this); return *this;
}

inline String& String::operator+=(char c)
{
  concat(*this, c, *this); return *this;
}

inline String operator + (String& x, String& y)
{
  String r; concat(x, y, r); return r;
}

inline String operator + (String& x, const char* t)
{
  String r; concat(x, t, r); return r;
}

inline String operator + (String& x, SubString& y)
{
  String r; concat(x, y, r); return r;
}

inline String operator + (String& x, char c)
{
  String r; concat(x, c, r); return r;
}

inline String operator + (SubString& x, String& y)
{
  String r; concat(x, y, r); return r;
}

inline String operator+(SubString& x, const char* y)
{
  String r; concat(x, y, r); return r;
}

inline String operator+(SubString& x, char c)
{
  String r; concat(x, c, r); return r;
}

inline String operator+(SubString& x, SubString& y)
{
  String r; concat(x, y, r); return r;
}
  
inline int String::length()
{ 
  return rep->len;
}

inline int String::empty()
{ 
  return rep->len == 0;
}

inline int String::operator ! ()
{ 
  return rep->len == 0;
}

inline char  String::operator [] (int i) 
{ 
  return rep->s[i];
}

inline int String::index(char c, int startpos = 0)
{
  return search(startpos, rep->len, c);
}

inline int String::index(const char* t, int startpos = 0)
{   
  return search(startpos, rep->len, t);
}

inline int String::index(String& y, int startpos = 0)
{   
  return search(startpos, rep->len, y.rep->s, y.rep->len);
}

inline int String::index(SubString& y, int startpos = 0)
{   
  return search(startpos, rep->len, &(y.S->rep->s[y.pos]), y.len);
}

inline int String::contains(char c)
{
  return search(0, rep->len, c) >= 0;
}

inline int SubString::contains(char c)
{
  return S->search(pos, pos+len, 0, c) >= 0;
}

inline int String::contains(const char* t)
{   
  return search(0, rep->len, t) >= 0;
}

inline int String::contains(String& y)
{   
  return search(0, rep->len, y.rep->s, y.rep->len) >= 0;
}

inline int String::contains(SubString& y)
{   
  return search(0, rep->len, &(y.S->rep->s[y.pos]), y.len) >= 0;
}

inline int SubString::contains(const char* t)
{   
  return S->search(pos, pos+len, t) >= 0;
}

inline int SubString::contains(String& y)
{   
  return S->search(pos, pos+len, y.rep->s, y.rep->len) >= 0;
}

inline int SubString::contains(SubString&  y)
{   
  return S->search(pos, pos+len, &(y.S->rep->s[y.pos]), y.len) >= 0;
}

inline int String::contains(char c, int p)
{
  char ch = c; return match(p, rep->len, 0, &ch, 1);
}

inline int String::matches(char c, int p = 0)
{
  char ch = c; return match(p, rep->len, 1, &ch, 1);
}

inline int String::contains(const char* t, int p)
{
  return match(p, rep->len, 0, t);
}

inline int String::matches(const char* t, int p = 0)
{
  return match(p, rep->len, 1, t);
}

inline int String::contains(String& y, int p)
{
  return match(p, rep->len, 0, y.rep->s, y.rep->len);
}

inline int String::matches(String& y, int p = 0)
{
  return match(p, rep->len, 1, y.rep->s, y.rep->len);
}

inline int String::contains(SubString& y, int p)
{
  return match(p, rep->len, 0, &(y.S->rep->s[y.pos]), y.len);
}

inline int String::matches(SubString& y, int p = 0)
{
  return match(p, rep->len, 1, &(y.S->rep->s[y.pos]), y.len);
}

inline int String::contains(Regex& r)
{
  int unused;
  return r.search(rep->s, rep->len, unused, 0);
}

inline int SubString::contains(Regex& r)
{
  int unused;
  return r.search(&(S->rep->s[pos]), len, unused, 0);
}

inline int String::contains(Regex& r, int p)
{
  return r.match(rep->s, rep->len, p);
}

inline int String::matches(Regex& r, int p = 0)
{
  int l = (p < 0)? -p : rep->len - p;
  return r.match(rep->s, rep->len, p) == l;
}

inline int SubString::matches(Regex& r)
{
  return r.match(&(S->rep->s[pos]), len, 0) == len;
}

inline const char* String::operator char*()
{ 
  return rep->s;
}

inline int String::index(Regex& r, int startpos = 0)
{
  int mlen;  return r.search(rep->s, rep->len, mlen, startpos);
}

inline const char* SubString::operator char*()
{ 
  return (char*)(String(*this)); 
}

inline  int SubString::length()
{ 
  return len;
}

inline  int SubString::empty()
{ 
  return len == 0;
}

inline  ostream& operator<<(ostream& s, String& x)
{ 
  s.put(x.rep->s); return s;
}

inline int operator==(String& x, String& y) 
{
  return x.rep->len == y.rep->len && compare(x, y) == 0; 
}

inline int operator!=(String& x, String& y)
{
  return x.rep->len != y.rep->len || compare(x, y) != 0; 
}

inline int operator>(String& x, String& y)
{
  return compare(x, y) > 0; 
}

inline int operator>=(String& x, String& y)
{
  return compare(x, y) >= 0; 
}

inline int operator<(String& x, String& y)
{
  return compare(x, y) < 0; 
}

inline int operator<=(String& x, String& y)
{
  return compare(x, y) <= 0; 
}

inline int operator==(String& x, SubString&  y) 
{
  return x.rep->len == y.len && compare(x, y) == 0; 
}

inline int operator!=(String& x, SubString&  y)
{
  return x.rep->len != y.len || compare(x, y) != 0; 
}

inline int operator>(String& x, SubString&  y)      
{
  return compare(x, y) > 0; 
}

inline int operator>=(String& x, SubString&  y)
{
  return compare(x, y) >= 0; 
}

inline int operator<(String& x, SubString&  y) 
{
  return compare(x, y) < 0; 
}

inline int operator<=(String& x, SubString&  y)
{
  return compare(x, y) <= 0; 
}

inline int operator==(String& x, const char* t) 
{
  return compare(x, t) == 0; 
}

inline int operator!=(String& x, const char* t) 
{
  return compare(x, t) != 0; 
}

inline int operator>(String& x, const char* t)  
{
  return compare(x, t) > 0; 
}

inline int operator>=(String& x, const char* t) 
{
  return compare(x, t) >= 0; 
}

inline int operator<(String& x, const char* t)  
{
  return compare(x, t) < 0; 
}

inline int operator<=(String& x, const char* t) 
{
  return compare(x, t) <= 0; 
}

inline int operator==(SubString& x, String& y) 
{
  return x.len == y.rep->len && compare(y, x) == 0; 
}

inline int operator!=(SubString& x, String& y)
{
  return x.len != y.rep->len || compare(y, x) != 0;
}

inline int operator>(SubString& x, String& y)      
{
  return compare(y, x) < 0;
}

inline int operator>=(SubString& x, String& y)     
{
  return compare(y, x) <= 0;
}

inline int operator<(SubString& x, String& y)      
{
  return compare(y, x) > 0;
}

inline int operator<=(SubString& x, String& y)     
{
  return compare(y, x) >= 0;
}

inline int operator==(SubString& x, SubString&  y) 
{
  return x.len == y.len && compare(x, y) == 0; 
}

inline int operator!=(SubString& x, SubString&  y)
{
  return x.len != y.len || compare(x, y) != 0;
}

inline int operator>(SubString& x, SubString&  y)      
{
  return compare(x, y) > 0;
}

inline int operator>=(SubString& x, SubString&  y)
{
  return compare(x, y) >= 0;
}

inline int operator<(SubString& x, SubString&  y) 
{
  return compare(x, y) < 0;
}

inline int operator<=(SubString& x, SubString&  y)
{
  return compare(x, y) <= 0;
}

inline int operator==(SubString& x, const char* t) 
{
  return compare(x, t) == 0; 
}

inline int operator!=(SubString& x, const char* t) 
{
  return compare(x, t) != 0;
}

inline int operator>(SubString& x, const char* t)  
{
  return compare(x, t) > 0; 
}

inline int operator>=(SubString& x, const char* t) 
{
  return compare(x, t) >= 0; 
}

inline int operator<(SubString& x, const char* t)  
{
  return compare(x, t) < 0; 
}

inline int operator<=(SubString& x, const char* t) 
{
  return compare(x, t) <= 0; 
}

inline void String::make_unique()
{
  if (rep->ref != 1) setlength(rep->len);
}

 


# 5 "/united1/users/others/andreas/include/System.h"


# 1 "/united1/users/others/andreas/include/Error.h"



void myerror(int, char* =0, char* =0, char* =0 );


# 7 "/united1/users/others/andreas/include/System.h"

# 1 "/united1/users/others/andreas/include/ClassSet.h"



# 1 "/usr/tools/lib/g++-include/String.h"
 
 






















# 928 "/usr/tools/lib/g++-include/String.h"

# 4 "/united1/users/others/andreas/include/ClassSet.h"

# 1 "/united1/users/others/andreas/include/Error.h"






# 5 "/united1/users/others/andreas/include/ClassSet.h"

# 1 "/united1/users/others/andreas/include/Set.h"



# 1 "/united1/users/others/andreas/include/Collec.h"



# 1 "/usr/tools/lib/g++-include/String.h"
 
 






















# 928 "/usr/tools/lib/g++-include/String.h"

# 4 "/united1/users/others/andreas/include/Collec.h"


extern class Object;

class Collec {

   friend class iterator;
   friend class Set;

   Object** first_;
   Object** last_;
   int array_size_;
   int base_size_;

   void enlarge( int );
   void reduce();

public:

   void add( Object* e )
   {
      if (e) {
         if ( size() >= array_size_ ) enlarge( array_size_ );
         *last_++ = e;
      }
   } 

   void add( Collec& );
   void  remove( Object* );
   void  remove_all( Object* );
   Object* find( Object* );

   int contains( Object* o ) { 
       return find(o) ? 1 : 0;  
   }
   
   int size()
   { 
      return last_ - first_;
   }

   int empty()
   {  
      return last_-first_ == 0; 
   }

   void clear()
   {
      last_ = first_;
   }

   friend ostream& operator<<( ostream&, Collec& );

   Collec& operator=( Collec& );

   Object* operator[]( int i )
   {
      if (i > size()) return 0;
      else return first_[ i-1 ];
   }

   Collec()
   {
      base_size_ = 16;
      array_size_ = base_size_;
      first_ = new Object*[array_size_];
      last_ = first_;
   }

   Collec( int b )
   {
      base_size_ = b;
      array_size_ = base_size_;
      first_ = new Object*[array_size_];
      last_ = first_;
   }
   Collec( Collec& );

   ~Collec()
   {
      delete( first_ );
   }

   virtual void printOn( ostream& strm );
};

class iterator {
   int index;
   Collec* coll;
public:

   Object* operator++()
   {  
      Object* ret;
      Object** current;
      if (index < 0) ret = 0;
      else {
         current = coll->first_ + index++;
         if (current < coll->last_ && current >= coll->first_) 
            ret = *current;
         else { 
           index = -1;
           ret = 0;
         } 
      } 
      return ret;
   } 
   
   Object* operator()()
   {  
      Object* ret;
      Object** current;
      if (index < 0) ret = 0;
      else {
         current = coll->first_ + index++;
         if (current < coll->last_ && current >= coll->first_) 
            ret = *current;
         else { 
           index = -1;
           ret = 0;
         } 
      } 
      return ret;
   } 
   
   Object* operator--()
   {  
      Object* ret;
      Object** current;
      if (index < 0) ret = 0;
      else {
         if (index==0) index = coll->size()+1;
         current = coll->first_ -1 + --index;
         if (current >= coll->first_ && current < coll->last_ ) 
            ret = *current;
         else {
           index = -1;
           ret = 0;
         }
      }
      return ret;
   } 
   
   void reset()
   {
      index = 0;
   }
   
   iterator( iterator& i )
   {
      coll = i.coll;
      index = i.index;
   }
   
   iterator( Collec& c )
   {
      coll = &c;
      index = 0;
   }
   
   iterator& operator=( iterator& i )
   {
      coll = i.coll;
      index = i.index;
      return *this;
   }
};


# 4 "/united1/users/others/andreas/include/Set.h"


class Set : public Collec {
public:

   void add( Object* e ) 
   {
      if ( !find(e) ) Collec::add(e);
   }

   void add( Collec& );

   Object* filter( Object* o ); 
     
   Set() : () {}
   Set( int i ) : (i) {}
   Set( Collec& );
   Set( Set& s ) : (s) {}
   ~Set() {}
};


# 6 "/united1/users/others/andreas/include/ClassSet.h"

# 1 "/united1/users/others/andreas/include/Object.h"



# 1 "/usr/tools/lib/g++-include/String.h"
 
 






















# 928 "/usr/tools/lib/g++-include/String.h"

# 4 "/united1/users/others/andreas/include/Object.h"

# 1 "/united1/users/others/andreas/include/MyFile.h"



# 1 "/usr/tools/lib/g++-include/stream.h"
 
 





















# 245 "/usr/tools/lib/g++-include/stream.h"

# 4 "/united1/users/others/andreas/include/MyFile.h"

# 1 "/usr/tools/lib/g++-include/String.h"
 
 






















# 928 "/usr/tools/lib/g++-include/String.h"

# 5 "/united1/users/others/andreas/include/MyFile.h"


class InputFile : public istream {
public:
   void readln();
   void getString( String&, int ); 
}; 

class OutputFile : public ostream {
public:
};


# 5 "/united1/users/others/andreas/include/Object.h"

# 1 "/united1/users/others/andreas/include/Class.h"



# 1 "/usr/tools/lib/g++-include/String.h"
 
 






















# 928 "/usr/tools/lib/g++-include/String.h"

# 4 "/united1/users/others/andreas/include/Class.h"

# 1 "/united1/users/others/andreas/include/MyFile.h"
# 17 "/united1/users/others/andreas/include/MyFile.h"

# 5 "/united1/users/others/andreas/include/Class.h"


class Class {   
   friend class Object;
   String cls;
   Class* super; 
public:
   Class( char* s, Class& c ) { cls = s; super = &c; }
   Class( char* s ) { cls = s; super = 0; }
   Class( String& s, Class& c ) { cls = s; super = &c; }
   Class( String& s ) { cls = s; super = 0; }
};

# 6 "/united1/users/others/andreas/include/Object.h"


extern Class ObjectClass;

class Object {   
   Class* cls;
public:
   int isMemberOf( Class& c ) { return &c == cls; }
   int isMemberOf( Class* c ) { return c == cls; }
   String className() { return cls->cls; } 
   Class* classObject() { return cls; }
   int isKindOf( Class& c );
   void set_class( Class* c ) { cls = c; } 
   void set_class( Class& c ) { cls = &c; } 
   Object() { cls = &ObjectClass; }

   virtual int isEqual( Object* o ) { return this == o; } 

   virtual void printOn( ostream& strm ) {
      strm << cls->cls << "::" << hex((int)this);
   }

   friend ostream& operator<<( ostream&, Object& ); 
};

# 7 "/united1/users/others/andreas/include/ClassSet.h"


class ClassSet : public Set {
public:
   Object* get( Class& c);
}; 


# 8 "/united1/users/others/andreas/include/System.h"

# 1 "/united1/users/others/andreas/include/BusSec.h"



# 1 "/united1/users/others/andreas/include/Physical.h"



# 1 "/united1/users/others/andreas/include/Element.h"



# 1 "/united1/users/others/andreas/include/Object.h"
# 30 "/united1/users/others/andreas/include/Object.h"

# 4 "/united1/users/others/andreas/include/Element.h"

# 1 "/united1/users/others/andreas/include/ClassSet.h"
# 14 "/united1/users/others/andreas/include/ClassSet.h"

# 5 "/united1/users/others/andreas/include/Element.h"


extern Class ElementClass;

class Element : public Object {   
public:
   ClassSet groups;

   Element() { set_class(&ElementClass); }
   virtual void printFull( ostream& ); 

};

# 4 "/united1/users/others/andreas/include/Physical.h"


extern Class PhysicalClass;

class Physical : public Element {   
   String id;
public:

   Physical( String& s ); 

   int isEqual( Object* o ); 

   String name() { return id; };

   void printOn( ostream& strm ) 
   { strm << className() << "::" << id; };

   void printFull( ostream& );
};

# 4 "/united1/users/others/andreas/include/BusSec.h"

# 1 "/united1/users/others/andreas/include/Matrix.h"



# 1 "/usr/tools/lib/g++-include/stream.h"
 
 





















# 245 "/usr/tools/lib/g++-include/stream.h"

# 4 "/united1/users/others/andreas/include/Matrix.h"

# 1 "/usr/tools/lib/g++-include/math.h"
 
 






















# 183 "/usr/tools/lib/g++-include/math.h"

# 5 "/united1/users/others/andreas/include/Matrix.h"


class Matrix {
   int row;
   int col;
   double** mat;
public:
   Matrix( int, int );
   Matrix( Matrix& );
   ~Matrix();
 
   double& operator()( int, int ); 
   void operator=( double );
   void operator=( Matrix& );
   void operator+=( Matrix& );
   void operator-=( Matrix& );

   double infNorm();
   friend Matrix operator+( Matrix&, Matrix& );
   friend Matrix operator-( Matrix&, Matrix& );
   friend Matrix operator*( Matrix&, Matrix& );
   friend Matrix operator*( double, Matrix& );
   friend Matrix inverse( Matrix& );
   friend Matrix transpose( Matrix& );

   void addprod( Matrix&, Matrix& );
   void addprod( double, Matrix& );
   void subprod( Matrix&, Matrix& );
   void subprod( double, Matrix& );
   void inverse();

   friend ostream& operator<<( ostream&, Matrix& );
   friend istream& operator>>( istream&, Matrix& );
};


# 5 "/united1/users/others/andreas/include/BusSec.h"


extern Class BusSecClass;

class BusSec : public Physical {   
   int typ;
public:
   ClassSet conn;
   Matrix x;

   BusSec( String& s );

   int type() { return typ; };

   void readIEEE( InputFile& ); 
   void printFull( ostream& ); 
};

# 9 "/united1/users/others/andreas/include/System.h"


class System : public ClassSet {
   BusSec* refBus;
public:
   int loadflowtype;
   double maxerror;
   double loadmultiplier;
   double capmultiplier;
   double impmultiplier;
   double volterror;
   double flowerror;
   double injerror;
   double voltacc;
   double flowacc;
   double injacc;
   double maxiter;
   int size;

   System();

   double subVolt;
   double basePower;
   double baseVolt;
   double baseAdm(); 
   double SubstVolt();

   void makeTopology();
   void loadflow();
   void loadflowTimer();
   void createMeasurements();
   void makeMeasurementTopology();
   void estimate();
   void printLoadflowResults( ostream& );
   void printEstimationResults( ostream& );
   void readIEEE( InputFile& );
   void readSimple( InputFile& );
   void readParameters( InputFile& );
   void printFull( ostream& );
   void makeTopology1();
   void initState1();
   void loadflow1();
   void printLoadflowResults1( ostream& );
}; 

extern System SYSTEM;

# 1 "System.c"


# 1 "/united1/users/others/andreas/include/Line.h"



# 1 "/united1/users/others/andreas/include/Branch.h"



# 1 "/united1/users/others/andreas/include/ImpEle.h"



# 1 "/united1/users/others/andreas/include/Physical.h"
# 23 "/united1/users/others/andreas/include/Physical.h"

# 4 "/united1/users/others/andreas/include/ImpEle.h"

# 1 "/united1/users/others/andreas/include/BusSec.h"
# 22 "/united1/users/others/andreas/include/BusSec.h"

# 5 "/united1/users/others/andreas/include/ImpEle.h"


extern Class ImpEleClass;

class ImpEle : public Physical {   
public:
   ImpEle( String& s );

   virtual BusSec* otherBus( BusSec* ) { return 0; };
   void printFull( ostream& );
};

# 4 "/united1/users/others/andreas/include/Branch.h"


extern Class BranchClass;

class Branch : public ImpEle {   
   BusSec* bus1;
   BusSec* bus2;
public:
   Branch( String&, BusSec*, BusSec* );

   virtual BusSec* otherBus( BusSec* ); 
   void printFull( ostream& );
};

# 4 "/united1/users/others/andreas/include/Line.h"

# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 5 "/united1/users/others/andreas/include/Line.h"


extern Class LineClass;

class Line : public Branch {   
public:
   double rPu;
   double xPu;
   Line( String&, BusSec*, BusSec* );
   
   double otherVoltage( double, Matrix& );
   double newVoltage( double, double, Matrix& );
   Matrix losses( double, Matrix& );

   void readIEEE( InputFile& );
   void readSimple( InputFile& );
   void printFull( ostream& ); 
};

# 3 "System.c"

# 1 "/united1/users/others/andreas/include/PQLoad.h"



# 1 "/united1/users/others/andreas/include/Shunt.h"



# 1 "/united1/users/others/andreas/include/ImpEle.h"
# 16 "/united1/users/others/andreas/include/ImpEle.h"

# 4 "/united1/users/others/andreas/include/Shunt.h"

# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 5 "/united1/users/others/andreas/include/Shunt.h"

# 1 "/united1/users/others/andreas/include/Error.h"






# 6 "/united1/users/others/andreas/include/Shunt.h"


extern Class ShuntClass;

class Shunt : public ImpEle {   
public:
   BusSec* bus;
   Shunt( String&, BusSec* );

   virtual Matrix flow( double ) { 
      myerror(1,"Flow must be imp. by subclass"); 
      Matrix m(1,1);
      return m;
   }
   virtual BusSec* otherBus( BusSec* ) { return 0; };
   void printFull( ostream& );
};

# 4 "/united1/users/others/andreas/include/PQLoad.h"

# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 5 "/united1/users/others/andreas/include/PQLoad.h"


extern Class PQLoadClass;

class PQLoad : public Shunt {   
   double p;
   double q;
public:
   PQLoad( String&, BusSec*, double, double );
  
   Matrix flow( double );
   double P() { return p; }
   double Q() { return q; } 
   void printFull( ostream& ); 
};

# 4 "System.c"

# 1 "/united1/users/others/andreas/include/Cap.h"



# 1 "/united1/users/others/andreas/include/Shunt.h"
# 23 "/united1/users/others/andreas/include/Shunt.h"

# 4 "/united1/users/others/andreas/include/Cap.h"

# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 5 "/united1/users/others/andreas/include/Cap.h"


extern Class CapClass;

class Cap : public Shunt {   
   double yPu;
public:
   Cap( String&, BusSec* );
  
   Matrix flow( double );
   Matrix voltageSensitivity( double );
   void readSimple( istream& );
   void printFull( ostream& ); 
};

# 5 "System.c"

# 1 "/united1/users/others/andreas/include/LfNode.h"



# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 4 "/united1/users/others/andreas/include/LfNode.h"

# 1 "/united1/users/others/andreas/include/Node.h"



# 1 "/united1/users/others/andreas/include/Conceptual.h"



# 1 "/united1/users/others/andreas/include/Element.h"
# 17 "/united1/users/others/andreas/include/Element.h"

# 4 "/united1/users/others/andreas/include/Conceptual.h"

# 1 "/united1/users/others/andreas/include/ClassSet.h"
# 14 "/united1/users/others/andreas/include/ClassSet.h"

# 5 "/united1/users/others/andreas/include/Conceptual.h"


extern Class ConceptualClass;

class Conceptual : public Element {   
public:
   ClassSet elements;

   Conceptual( Element* ); 
   void printFull( ostream& );
};

# 4 "/united1/users/others/andreas/include/Node.h"


extern Class NodeClass;

class Node : public Conceptual {   
public:

   Node( Element* ); 
   void printFull( ostream& );
};

# 5 "/united1/users/others/andreas/include/LfNode.h"

# 1 "/united1/users/others/andreas/include/Line.h"
# 23 "/united1/users/others/andreas/include/Line.h"

# 6 "/united1/users/others/andreas/include/LfNode.h"

# 1 "/united1/users/others/andreas/include/Cap.h"
# 19 "/united1/users/others/andreas/include/Cap.h"

# 7 "/united1/users/others/andreas/include/LfNode.h"

# 1 "/united1/users/others/andreas/include/TopSet.h"



# 1 "/united1/users/others/andreas/include/Collec.h"
# 172 "/united1/users/others/andreas/include/Collec.h"

# 4 "/united1/users/others/andreas/include/TopSet.h"


class TopSet : public Collec {
public:
};


# 8 "/united1/users/others/andreas/include/LfNode.h"

# 1 "/united1/users/others/andreas/include/PQLoad.h"
# 20 "/united1/users/others/andreas/include/PQLoad.h"

# 9 "/united1/users/others/andreas/include/LfNode.h"


extern Class LfNodeClass;

class LfNode : public Node {   
   Matrix s;
   Matrix ds;
   double u;
   Line* line;
   PQLoad* load;
   Cap* cap;
   TopSet children;
   LfNode* parent;
   double err;
public:
   LfNode( Element* ); 
   void initVoltage( double v ) { u = v*v; } 
   void makeTopology(); 
   double lfStep();
   void lfstep();
   void updateError( double );
   void resetState();
   void makeMes();
   void printLf( ostream& );
   void printStateK( ostream& );
   void printState( ostream& );
   void printFull( ostream& );
   void printOn( ostream& );
   double P();
   double Q();
   double Pinj();
   double Qinj();
   double I();
   double J();
   double Iinj();
   double Jinj();
   double V(); 
};

# 6 "System.c"

# 1 "/united1/users/others/andreas/include/Lf1Node.h"



# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 4 "/united1/users/others/andreas/include/Lf1Node.h"

# 1 "/united1/users/others/andreas/include/Node.h"
# 14 "/united1/users/others/andreas/include/Node.h"

# 5 "/united1/users/others/andreas/include/Lf1Node.h"

# 1 "/united1/users/others/andreas/include/Line.h"
# 23 "/united1/users/others/andreas/include/Line.h"

# 6 "/united1/users/others/andreas/include/Lf1Node.h"

# 1 "/united1/users/others/andreas/include/Cap.h"
# 19 "/united1/users/others/andreas/include/Cap.h"

# 7 "/united1/users/others/andreas/include/Lf1Node.h"

# 1 "/united1/users/others/andreas/include/TopSet.h"
# 10 "/united1/users/others/andreas/include/TopSet.h"

# 8 "/united1/users/others/andreas/include/Lf1Node.h"

# 1 "/united1/users/others/andreas/include/PQLoad.h"
# 20 "/united1/users/others/andreas/include/PQLoad.h"

# 9 "/united1/users/others/andreas/include/Lf1Node.h"


extern Class Lf1NodeClass;

class Lf1Node : public Node {   
   Matrix s;
   Matrix ds;
   double u;
   double du;
   Matrix jd;
   Matrix ju;
   Line* line;
   PQLoad* load;
   Cap* cap;
   TopSet children;
   Lf1Node* parent;
public:
   Lf1Node( Element* ); 
   void initVoltage( double v ) { u = v*v; } 
   void makeTopology(); 
   void initState();
   void initJacobianLocal();
   double uerr();
   Matrix serr();
   void forwardStepLocal(); 
   void forwardStep(); 
   void backwardStepLocal(); 
   void backwardStep(); 
   double lfstep();
   void printLf( ostream& );
   void printStateK( ostream& );
   void printState( ostream& );
   void printFull( ostream& );
   void printOn( ostream& );
};

# 7 "System.c"

# 1 "/united1/users/others/andreas/include/EstNode.h"



# 1 "/united1/users/others/andreas/include/Matrix.h"
# 40 "/united1/users/others/andreas/include/Matrix.h"

# 4 "/united1/users/others/andreas/include/EstNode.h"

# 1 "/united1/users/others/andreas/include/Node.h"
# 14 "/united1/users/others/andreas/include/Node.h"

# 5 "/united1/users/others/andreas/include/EstNode.h"

# 1 "/united1/users/others/andreas/include/Line.h"
# 23 "/united1/users/others/andreas/include/Line.h"

# 6 "/united1/users/others/andreas/include/EstNode.h"

# 1 "/united1/users/others/andreas/include/TopSet.h"
# 10 "/united1/users/others/andreas/include/TopSet.h"

# 7 "/united1/users/others/andreas/include/EstNode.h"

# 1 "/united1/users/others/andreas/include/Measure.h"



# 1 "/united1/users/others/andreas/include/Physical.h"
# 23 "/united1/users/others/andreas/include/Physical.h"

# 4 "/united1/users/others/andreas/include/Measure.h"

# 1 "/united1/users/others/andreas/include/BusSec.h"
# 22 "/united1/users/others/andreas/include/BusSec.h"

# 5 "/united1/users/others/andreas/include/Measure.h"


extern Class MeasureClass;

class Measure : public Physical {   
   double v;
   double vacc;
   double pacc;
   double p;
   double q;
   double pinj; 
   double qinj; 
public:
   BusSec* bus;

   Measure( String&, BusSec* );
   double wu(); 
   double ws(); 
   double wsinj(); 
   double wflow();
   double winj();
   double wv();
   double V();
   double U();
   double P() { return p; }
   double Pinj() { return pinj; }
   double Q() { return q; }
   double Qinj() { return qinj; }
   double I();
   double Iinj();
   double J();
   double Jinj();
   void update( double, double, double, double, double );
   void readSimple( istream& );
   void printFull( ostream& );
   void printState( ostream& );
};

# 8 "/united1/users/others/andreas/include/EstNode.h"

# 1 "/united1/users/others/andreas/include/LfNode.h"
# 47 "/united1/users/others/andreas/include/LfNode.h"

# 9 "/united1/users/others/andreas/include/EstNode.h"


extern Class EstNodeClass;


class EstNode : public Node {   
   friend class EstBranch;

   Matrix x;
   Matrix dx;
   Matrix err;
   Matrix grad;

   Matrix ms;
   Matrix msinj;
   double mu;

   Matrix d;
   Matrix l;

   Matrix dtemp;
   Matrix ltemp;
   Matrix errtemp;

   Line* line;
   Measure* measure;
   TopSet branches;
   TopSet children;
   EstNode* parent;

   static double maxerr;
   static int numNodes;

public:
   static double totalerror; 
   static double merrit; 

   EstNode( Element* ); 

   void initVoltage( double v ) { x(3,1) = v*v; } 
   void updateError( double ); 
   void updateMerrit(); 

   EstBranch* branchTo( EstNode* );
   void makeTopology(); 
   void makeBranches();

   void updateGain();
   void factorGain();
   void backwardSubst();
   void forwardSubst();

   void measErr();
   void Error();

   void updateX();

   void initState();
   double estStep();
   void eststep();
   void eststep1();
   void eststep2();
   void eststep3();
   void eststep4();
   void eststep5();

   void printRes( ostream& );
   void printResults( ostream& );
   void printState( ostream& );
   void printFull( ostream& );
   void printOn( ostream& );
   LfNode* lfnode();
   void check();

   double z2();
   double u2();
   double s2();
   double rPu();
   double xPu();
   double pp();
   double pq();
   double pu();
   double qp();
   double qq();
   double qu();
   double cp();
   double cq();
   double cu();
   double V();
   double P();
   double Q();
   double Pinj();
   double Qinj();
};

# 8 "System.c"

# 1 "/united1/users/others/andreas/include/Measure.h"
# 42 "/united1/users/others/andreas/include/Measure.h"

# 9 "System.c"


System SYSTEM;

System::System() {
   maxerror = 0.001;
   maxiter = 10;
   loadmultiplier = 1.0;
   capmultiplier = 1.0;
   impmultiplier = 1.0;
   volterror = 1.0;
   injerror = 1.0;
   flowerror = 1.0;
   voltacc = 1.0;
   injacc = 1.0;
   flowacc = 1.0;
   loadflowtype = 0;
}

void System::readParameters( InputFile& strm ) {
   strm >> loadflowtype;
   strm.readln();
   strm >> loadmultiplier;
   strm.readln();
   strm >> impmultiplier;
   strm.readln();
   strm >> capmultiplier;
   strm.readln();
   strm >> volterror;
   strm. readln();
   strm >> flowerror;
   strm. readln();
   strm >> injerror;
   strm. readln();
   strm >> voltacc;
   strm. readln();
   strm >> flowacc;
   strm. readln();
   strm >> injacc;
   strm. readln();
   strm >> maxerror;
   strm.readln();
   strm >> maxiter;
}

void System::readSimple( InputFile& strm ) {
   BusSec *b1,*b2;
   String s,s1,s2;
   double p,q;

   strm.readln();
   strm.readln();

   strm >> subVolt;
   subVolt *= 1000.0;
   strm >> basePower;
   basePower *= 1000.0;
   strm >> baseVolt;
   baseVolt *= 1000.0;
   subVolt = subVolt / baseVolt;
   strm.readln();
 
   strm.readln();
   strm.readln();

   cerr << "Starting to read the Buses\n";

   strm >> s1;
   b1 = new BusSec( s1 );
   cerr << "First Bus is the Reference Bus " << *b1 << "\n";
   add(b1);
   refBus = b1;
   Line* l;
   PQLoad* pq;
   while ( s1 != "-999" ) {
      b1 = new BusSec( s1 );
      b1 = (BusSec*) filter( b1 );
      strm >> s2;
      b2 = new BusSec( s2 );
      add(b2); 
      s = s1;
      s += "-";
      s += s2;
      l = new Line( s, b1, b2 );
      l->readSimple( strm );
      strm >> p;
      strm >> q;
      pq = new PQLoad( s2, b2, p, q ); 
      strm >> s1;
   } 
   strm.readln();
   strm.readln();
   cerr << "Starting to read the Capacitors\n";
   strm >> s1;
   cerr << "First Capacitor is " << s1 << "\n"; 
   Cap* c;
   while ( s1 != "-999" ) {
      b1 = new BusSec( s1 );
      b1 = (BusSec*) filter( b1 );
      c = new Cap( s1, b1 );
      c->readSimple( strm );
      strm >> s1;
   }
   strm.readln();
   strm.readln();
   cerr << "Starting to read the Measurements\n";
   strm >> s1;
   cerr << "First Measurement is " << s1 << "\n";
   Measure* m;
   while ( s1 != "-999" ) {
      b1 = new BusSec( s1 );
      b1 = (BusSec*) filter( b1 );
      m = new Measure( s1, b1 );
      m->readSimple( strm );
      strm >> s1;
   }
}

void System::readIEEE( InputFile& strm ) {
   BusSec *b,*b1,*b2;
   String s1,s2,s;
   char buf[80];
   basePower = 100.0;
   strm.readln();
   strm.readln();

   strm >> s;
   while ( s != "-999" ) {
      b = new BusSec( s );
      b->readIEEE( strm );
      add(b);
      strm >> s;
      if (b->type() == 3) refBus = b;
      baseVolt = b->x(2,1);
   }
   strm.readln();
   strm.readln();
   strm >> s1;
   while ( s1 != "-999" ) {
      b1 = new BusSec( s1 );
      b1 = (BusSec*) filter(b1);
      strm >> s2;
      b2 = new BusSec( s2 );
      b2 = (BusSec*) filter(b2);
      s = s1;
      s += "=";
      s += s2;
      Line* l;
      l = new Line( s, b1, b2 );
      l->readIEEE( strm );
      strm >> s1;
   } 
}

void System::makeTopology1() {
   Lf1Node* l;
   l = new Lf1Node (refBus);
   l->makeTopology();
}

void System::makeTopology() {
   LfNode* l;
   l = new LfNode (refBus);
   l->makeTopology();
}

void System::makeMeasurementTopology() {
   EstNode* e;
   e = new EstNode (refBus);
   e->makeTopology();
}

void System::loadflow() {
   LfNode* l;
   double err;
   double maxerr = maxerror;
   l = (LfNode*) refBus->groups.get( LfNodeClass );
   for (int i=1; i<=10; i++) {
      l->initVoltage( SubstVolt() );
      err = l->lfStep(); 
      cerr << "   Iteration " << i << ":  Error = " << err;
      cerr << "    log(err)  = " << log(err) << "\n";
      if (err < maxerr) {
         cerr << "Loadflow converged in " << i << " Iterations\n";
         return;
      }
   } 
   cerr << "Loadflow did not converge in " << i-1 << " Iterations\n";
}
   
void System::loadflow1() {
   Lf1Node* l;
   double err;
   double maxerr = maxerror;
   l = (Lf1Node*) refBus->groups.get( Lf1NodeClass );
   l->initVoltage( SubstVolt() );
   l->initState();
   for (int i=1; i<=10; i++) {
      err = l->lfstep(); 
      cerr << "   Iteration " << i << ":  Error = " << err;
      cerr << "    log(err)  = " << log(err) << "\n";
      if (err < maxerr) {
         cerr << "Loadflow converged in " << i << " Iterations\n";
         return;
      }
   } 
   cerr << "Loadflow did not converge in " << i-1 << " Iterations\n";
}
   
void System::estimate() {
   EstNode* slack;
   double err;
   double maxerr = maxerror;
   slack = (EstNode*) refBus->groups.get( EstNodeClass );
   slack->initVoltage( SubstVolt() );
   slack->initState();
 
   for (int i=1; i<=maxiter; i++) {
      cerr << "   Starting the " << i << "th iteration\n";
      err = slack->estStep(); 
      cerr << "   Iteration " << i;
      cerr << ":  Error = " << err;
      cerr << "   log(err) = " << log(err) << "\n";
      cerr << "   Total Residuals = " << EstNode::totalerror << "\n";
      cerr << "   Merrit Function = " << EstNode::merrit << "\n";
      if (err < maxerr) {
         cerr << "Estimator converged in " << i << " Iterations\n";
         return;
      }
   } 
   cerr << "Estimator did not converge in " << i-1 << " Iterations\n";
}
   
void System::loadflowTimer() {
   LfNode* l;
   double err;
   double maxerr = 0.001;
   int maxiter = 10;
   l = (LfNode*) refBus->groups.get( LfNodeClass );
   int i;
   for (int j=1; j<=100; j++) {
      l->resetState();
      for (i=1; i<=maxiter; i++) {
         l->initVoltage( SubstVolt() );
         err = l->lfStep(); 
         if (err < maxerr) {
            break;
         }
      } 
   }
   cerr << j-1 << " Loadflows with " << i-1 << " Iterations\n";
}
   
void System::initState1() {
   Lf1Node* l;
   l = (Lf1Node*) refBus->groups.get( Lf1NodeClass );
   l->initVoltage( SubstVolt() );
   l->initState();
}

void System::printLoadflowResults1( ostream& o ) {
   Lf1Node* l;
   l = (Lf1Node*) refBus->groups.get( Lf1NodeClass );
   l->printLf( o );
}

void System::printLoadflowResults( ostream& o ) {
   LfNode* l;
   l = (LfNode*) refBus->groups.get( LfNodeClass );
   l->printLf( o );
}

void System::printEstimationResults( ostream& o ) {
   EstNode* l;
   l = (EstNode*) refBus->groups.get( EstNodeClass );
   l->printResults( o );
}

void System::createMeasurements() {
   LfNode* l;
   l = (LfNode*) refBus->groups.get( LfNodeClass );
   l->makeMes();
}
   
void System::printFull( ostream& o ) {
   o << "Global Object System:\n";
   o << "   refBus = " << *refBus << "\n";
   o << "   subVolt = " << subVolt << "\n";
   o << "   basePower = " << basePower << "\n";
   o << "   baseVolt = " << baseVolt << "\n";
}


double System::baseAdm() {
   return basePower / ( baseVolt * baseVolt );
}

double System::SubstVolt() {
   return subVolt;
}