p700.c

来自「this is a gcc file, you can download it 」· C语言 代码 · 共 2,385 行 · 第 1/3 页

// Special g++ Options: -Wno-deprecated
// prms-id: 700

//# 1 "../../../../libg++/etc/benchmarks/dhrystone.cc"

























//# 1 "../../../../libg++/etc/benchmarks/Int.h" 1











































































class Int
{
protected:
  int          rep;



public:
               Int ();
               Int (const int  b);
               Int (const Int& b);
              ~Int();

               operator int() const;

  inline virtual  int   val() const;

  inline virtual  void  operator  = (const int);
  inline virtual  void  operator  = (const Int&);

  inline virtual  void  negate();
  inline virtual  void  complement();
  inline virtual  void  operator ++ ();
  inline virtual  void  operator -- ();

  inline virtual  void  operator += (const Int &  );
  inline virtual  void  operator -= (const Int &  );
  inline virtual  void  operator *= (const Int &  );
  inline virtual  void  operator /= (const Int &  );
  inline virtual  void  operator %= (const Int &  );
  inline virtual  void  operator |= (const Int &  );
  inline virtual  void  operator &= (const Int &  );
  inline virtual  void  operator ^= (const Int &  );
  inline virtual  void  operator <<=(const Int &  );
  inline virtual  void  operator >>=(const Int &  );


  inline virtual  void  operator += (const int);
  inline virtual  void  operator -= (const int);
  inline virtual  void  operator *= (const int);
  inline virtual  void  operator /= (const int);
  inline virtual  void  operator %= (const int);
  inline virtual  void  operator |= (const int);
  inline virtual  void  operator &= (const int);
  inline virtual  void  operator ^= (const int);
  inline virtual  void  operator <<=(const int);
  inline virtual  void  operator >>=(const int);


};

inline  int  Int::val() const { return rep; }
inline       Int::operator int() const { return val(); }

inline       Int::Int () :rep(0) {}
inline       Int::Int (const int  b) :rep(b) {}
inline       Int::Int (const Int& b) :rep(b.Int::val()) {}
inline       Int::~Int() {}

inline  void  Int::operator  = (const int  b)
{ rep = b;  ; }
inline  void  Int::operator  = (const Int&  b)
{ rep = b.Int::val();  ; }

inline  void  Int::complement()
{ rep = ~rep;  ; }
inline  void  Int::negate()
{ rep = -rep;  ; }
inline  void  Int::operator ++ ()
{ ++rep;  ; }
inline  void  Int::operator -- ()
{ --rep;  ; }

inline  void  Int::operator += (const Int &   b)
{ rep += b.Int::val();  ; }
inline  void  Int::operator -= (const Int &   b)
{ rep -= b.Int::val();  ; }
inline  void  Int::operator *= (const Int &   b)
{ rep *= b.Int::val();  ; }
inline  void  Int::operator /= (const Int &   b)
{ rep /= b.Int::val();  ; }
inline  void  Int::operator %= (const Int &   b)
{ rep %= b.Int::val();  ; }
inline  void  Int::operator |= (const Int &   b)
{ rep |= b.Int::val();  ; }
inline  void  Int::operator &= (const Int &   b)
{ rep &= b.Int::val();  ; }
inline  void  Int::operator ^= (const Int &   b)
{ rep ^= b.Int::val();  ; }
inline  void  Int::operator <<=(const Int &   b)
{ rep <<= b.Int::val();  ; }
inline  void  Int::operator >>=(const Int &   b)
{ rep >>= b.Int::val();  ; }



inline  void  Int::operator += (const int b)
{ rep += b;  ; }
inline  void  Int::operator -= (const int b)
{ rep -= b;  ; }
inline  void  Int::operator *= (const int b)
{ rep *= b;  ; }
inline  void  Int::operator /= (const int b)
{ rep /= b;  ; }
inline  void  Int::operator %= (const int b)
{ rep %= b;  ; }
inline  void  Int::operator |= (const int b)
{ rep |= b;  ; }
inline  void  Int::operator &= (const int b)
{ rep &= b;  ; }
inline  void  Int::operator ^= (const int b)
{ rep ^= b;  ; }
inline  void  Int::operator <<=(const int b)
{ rep <<= b;  ; }
inline  void  Int::operator >>=(const int b)
{ rep >>= b;  ; }


inline  int& operator  = (int& a,  const Int &   b)
{ a = b.Int::val(); return a;}	// WARNING - 
inline  int& operator += (int& a,  const Int &   b)
{ a += b.Int::val(); return a; }
inline  int& operator -= (int& a,  const Int &   b)
{ a -= b.Int::val(); return a;}
inline  int& operator *= (int& a,  const Int &   b)
{ a *= b.Int::val(); return a;}
inline  int& operator /= (int& a,  const Int &   b)
{ a /= b.Int::val(); return a;}
inline  int& operator %= (int& a,  const Int &   b)
{ a %= b.Int::val(); return a;}
inline  int& operator |= (int& a,  const Int &   b)
{ a |= b.Int::val(); return a;}
inline  int& operator &= (int& a,  const Int &   b)
{ a &= b.Int::val(); return a;}
inline  int& operator ^= (int& a,  const Int &   b)
{ a ^= b.Int::val(); return a;}
inline  int& operator <<=(int& a,  const Int &   b)
{ a <<= b.Int::val(); return a;}
inline  int& operator >>=(int& a,  const Int &   b)
{ a >>= b.Int::val(); return a;}



//# 289 "../../../../libg++/etc/benchmarks/Int.h"


inline  Int  operator -  (const Int &   a) return r(a)
{ r.negate();  }
inline  Int  operator ~  (const Int &   a) return r(a)
{ r.complement();  }

inline  Int  operator +  (const Int &   a, const Int &   b) return r(a)
{ r += b.Int::val();  }
inline  Int  operator -  (const Int &   a, const Int &   b) return r(a)
{ r -= b.Int::val();  }
inline  Int  operator *  (const Int &   a, const Int &   b) return r(a)
{ r *= b.Int::val();  }
inline  Int  operator /  (const Int &   a, const Int &   b) return r(a)
{ r /= b.Int::val();  }
inline  Int  operator %  (const Int &   a, const Int &   b) return r(a)
{ r %= b.Int::val();  }
inline  Int  operator << (const Int &   a, const Int &   b) return r(a)
{ r <<= b.Int::val();  }
inline  Int  operator >> (const Int &   a, const Int &   b) return r(a)
{ r >>= b.Int::val();  }
inline  Int  operator &  (const Int &   a, const Int &   b) return r(a)
{ r &= b.Int::val();  }
inline  Int  operator |  (const Int &   a, const Int &   b) return r(a)
{ r |= b.Int::val();  }
inline  Int  operator ^  (const Int &   a, const Int &   b) return r(a)
{ r ^= b.Int::val();  }

inline  Int  operator +  (const Int &   a, const int b) return r(a)
{ r += b;  }
inline  Int  operator -  (const Int &   a, const int b) return r(a)
{ r -= b;  }
inline  Int  operator *  (const Int &   a, const int b) return r(a)
{ r *= b;  }
inline  Int  operator /  (const Int &   a, const int b) return r(a)
{ r /= b;  }
inline  Int  operator %  (const Int &   a, const int b) return r(a)
{ r %= b;  }
inline  Int  operator << (const Int &   a, const int b) return r(a)
{ r <<= b;  }
inline  Int  operator >> (const Int &   a, const int b) return r(a)
{ r >>= b;  }
inline  Int  operator &  (const Int &   a, const int b) return r(a)
{ r &= b;  }
inline  Int  operator |  (const Int &   a, const int b) return r(a)
{ r |= b;  }
inline  Int  operator ^  (const Int &   a, const int b) return r(a)
{ r ^= b;  }

inline  Int  operator +  (const int a, const Int &   b) return r(a)
{ r += b.Int::val();  }
inline  Int  operator -  (const int a, const Int &   b) return r(a)
{ r -= b.Int::val();  }
inline  Int  operator *  (const int a, const Int &   b) return r(a)
{ r *= b.Int::val();  }
inline  Int  operator /  (const int a, const Int &   b) return r(a)
{ r /= b.Int::val();  }
inline  Int  operator %  (const int a, const Int &   b) return r(a)
{ r %= b.Int::val();  }
inline  Int  operator << (const int a, const Int &   b) return r(a)
{ r <<= b.Int::val();  }
inline  Int  operator >> (const int a, const Int &   b) return r(a)
{ r >>= b.Int::val();  }
inline  Int  operator &  (const int a, const Int &   b) return r(a)
{ r &= b.Int::val();  }
inline  Int  operator |  (const int a, const Int &   b) return r(a)
{ r |= b.Int::val();  }
inline  Int  operator ^  (const int a, const Int &   b) return r(a)
{ r ^= b.Int::val();  }



inline  int  operator !  (const Int &   a) { return !a.Int::val(); }

inline  int  operator == (const Int &   a, const Int &   b)
{ return a.Int::val() == b.Int::val(); }
inline  int  operator != (const Int &   a, const Int &   b)
{ return a.Int::val() != b.Int::val(); }
inline  int  operator <  (const Int &   a, const Int &   b)
{ return a.Int::val() <  b.Int::val(); }
inline  int  operator <= (const Int &   a, const Int &   b)
{ return a.Int::val() <= b.Int::val(); }
inline  int  operator >  (const Int &   a, const Int &   b)
{ return a.Int::val() >  b.Int::val(); }
inline  int  operator >= (const Int &   a, const Int &   b)
{ return a.Int::val() >= b.Int::val(); }

inline  int  operator == (const Int &   a, const int b)
{ return a.Int::val() == b; }
inline  int  operator != (const Int &   a, const int b)
{ return a.Int::val() != b; }
inline  int  operator <  (const Int &   a, const int b)
{ return a.Int::val() <  b; }
inline  int  operator <= (const Int &   a, const int b)
{ return a.Int::val() <= b; }
inline  int  operator >  (const Int &   a, const int b)
{ return a.Int::val() >  b; }
inline  int  operator >= (const Int &   a, const int b)
{ return a.Int::val() >= b; }

inline  int  operator == (const int a, const Int &   b)
{ return a == b.Int::val(); }
inline  int  operator != (const int a, const Int &   b)
{ return a != b.Int::val(); }
inline  int  operator <  (const int a, const Int &   b)
{ return a <  b.Int::val(); }
inline  int  operator <= (const int a, const Int &   b)
{ return a <= b.Int::val(); }
inline  int  operator >  (const int a, const Int &   b)
{ return a >  b.Int::val(); }
inline  int  operator >= (const int a, const Int &   b)
{ return a >= b.Int::val(); }



//# 26 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2

//# 1 "../../../../libg++/etc/benchmarks/Char.h" 1













































































class Char
{
protected:
  char          rep;



public:
               Char ();
               Char (const char  b);
               Char (const Char& b);
              ~Char();

               operator char() const;

  inline virtual  char   val() const;

  inline virtual  void  operator  = (const char);
  inline virtual  void  operator  = (const Char&);

  inline virtual  void  negate();
  inline virtual  void  complement();
  inline virtual  void  operator ++ ();
  inline virtual  void  operator -- ();

  inline virtual  void  operator += (const Char &  );
  inline virtual  void  operator -= (const Char &  );
  inline virtual  void  operator *= (const Char &  );
  inline virtual  void  operator /= (const Char &  );
  inline virtual  void  operator %= (const Char &  );
  inline virtual  void  operator |= (const Char &  );
  inline virtual  void  operator &= (const Char &  );
  inline virtual  void  operator ^= (const Char &  );
  inline virtual  void  operator <<=(const Char &  );
  inline virtual  void  operator >>=(const Char &  );


  inline virtual  void  operator += (const char);
  inline virtual  void  operator -= (const char);
  inline virtual  void  operator *= (const char);
  inline virtual  void  operator /= (const char);
  inline virtual  void  operator %= (const char);
  inline virtual  void  operator |= (const char);
  inline virtual  void  operator &= (const char);
  inline virtual  void  operator ^= (const char);
  inline virtual  void  operator <<=(const char);
  inline virtual  void  operator >>=(const char);


};

inline  char  Char::val() const { return rep; }
inline       Char::operator char() const { return val(); }

inline       Char::Char () :rep(0) {}
inline       Char::Char (const char  b) :rep(b) {}
inline       Char::Char (const Char& b) :rep(b.Char::val()) {}
inline       Char::~Char() {}

inline  void  Char::operator  = (const char  b)
{ rep = b;  ; }
inline  void  Char::operator  = (const Char&  b)
{ rep = b.Char::val();  ; }

inline  void  Char::complement()
{ rep = ~rep;  ; }
inline  void  Char::negate()
{ rep = -rep;  ; }
inline  void  Char::operator ++ ()
{ ++rep;  ; }
inline  void  Char::operator -- ()
{ --rep;  ; }

inline  void  Char::operator += (const Char &   b)
{ rep += b.Char::val();  ; }
inline  void  Char::operator -= (const Char &   b)
{ rep -= b.Char::val();  ; }
inline  void  Char::operator *= (const Char &   b)
{ rep *= b.Char::val();  ; }
inline  void  Char::operator /= (const Char &   b)
{ rep /= b.Char::val();  ; }
inline  void  Char::operator %= (const Char &   b)
{ rep %= b.Char::val();  ; }
inline  void  Char::operator |= (const Char &   b)
{ rep |= b.Char::val();  ; }
inline  void  Char::operator &= (const Char &   b)
{ rep &= b.Char::val();  ; }
inline  void  Char::operator ^= (const Char &   b)
{ rep ^= b.Char::val();  ; }
inline  void  Char::operator <<=(const Char &   b)
{ rep <<= b.Char::val();  ; }
inline  void  Char::operator >>=(const Char &   b)
{ rep >>= b.Char::val();  ; }



inline  void  Char::operator += (const char b)
{ rep += b;  ; }
inline  void  Char::operator -= (const char b)
{ rep -= b;  ; }
inline  void  Char::operator *= (const char b)
{ rep *= b;  ; }
inline  void  Char::operator /= (const char b)
{ rep /= b;  ; }
inline  void  Char::operator %= (const char b)
{ rep %= b;  ; }
inline  void  Char::operator |= (const char b)
{ rep |= b;  ; }
inline  void  Char::operator &= (const char b)
{ rep &= b;  ; }
inline  void  Char::operator ^= (const char b)
{ rep ^= b;  ; }
inline  void  Char::operator <<=(const char b)
{ rep <<= b;  ; }
inline  void  Char::operator >>=(const char b)
{ rep >>= b;  ; }


inline  char& operator  = (char& a,  const Char &   b)
{ a = b.Char::val(); return a;}	// WARNING - 
inline  char& operator += (char& a,  const Char &   b)
{ a += b.Char::val(); return a; }
inline  char& operator -= (char& a,  const Char &   b)
{ a -= b.Char::val(); return a;}
inline  char& operator *= (char& a,  const Char &   b)
{ a *= b.Char::val(); return a;}
inline  char& operator /= (char& a,  const Char &   b)
{ a /= b.Char::val(); return a;}
inline  char& operator %= (char& a,  const Char &   b)
{ a %= b.Char::val(); return a;}
inline  char& operator |= (char& a,  const Char &   b)
{ a |= b.Char::val(); return a;}
inline  char& operator &= (char& a,  const Char &   b)
{ a &= b.Char::val(); return a;}
inline  char& operator ^= (char& a,  const Char &   b)
{ a ^= b.Char::val(); return a;}
inline  char& operator <<=(char& a,  const Char &   b)
{ a <<= b.Char::val(); return a;}
inline  char& operator >>=(char& a,  const Char &   b)
{ a >>= b.Char::val(); return a;}



//# 291 "../../../../libg++/etc/benchmarks/Char.h"


inline  Char  operator -  (const Char &   a) return r(a)
{ r.negate();  }
inline  Char  operator ~  (const Char &   a) return r(a)
{ r.complement();  }

inline  Char  operator +  (const Char &   a, const Char &   b) return r(a)
{ r += b.Char::val();  }
inline  Char  operator -  (const Char &   a, const Char &   b) return r(a)
{ r -= b.Char::val();  }
inline  Char  operator *  (const Char &   a, const Char &   b) return r(a)
{ r *= b.Char::val();  }
inline  Char  operator /  (const Char &   a, const Char &   b) return r(a)
{ r /= b.Char::val();  }
inline  Char  operator %  (const Char &   a, const Char &   b) return r(a)
{ r %= b.Char::val();  }
inline  Char  operator << (const Char &   a, const Char &   b) return r(a)
{ r <<= b.Char::val();  }
inline  Char  operator >> (const Char &   a, const Char &   b) return r(a)
{ r >>= b.Char::val();  }
inline  Char  operator &  (const Char &   a, const Char &   b) return r(a)
{ r &= b.Char::val();  }
inline  Char  operator |  (const Char &   a, const Char &   b) return r(a)
{ r |= b.Char::val();  }
inline  Char  operator ^  (const Char &   a, const Char &   b) return r(a)
{ r ^= b.Char::val();  }

inline  Char  operator +  (const Char &   a, const char b) return r(a)
{ r += b;  }
inline  Char  operator -  (const Char &   a, const char b) return r(a)
{ r -= b;  }
inline  Char  operator *  (const Char &   a, const char b) return r(a)
{ r *= b;  }
inline  Char  operator /  (const Char &   a, const char b) return r(a)
{ r /= b;  }
inline  Char  operator %  (const Char &   a, const char b) return r(a)
{ r %= b;  }
inline  Char  operator << (const Char &   a, const char b) return r(a)
{ r <<= b;  }
inline  Char  operator >> (const Char &   a, const char b) return r(a)
{ r >>= b;  }
inline  Char  operator &  (const Char &   a, const char b) return r(a)
{ r &= b;  }
inline  Char  operator |  (const Char &   a, const char b) return r(a)
{ r |= b;  }
inline  Char  operator ^  (const Char &   a, const char b) return r(a)
{ r ^= b;  }

inline  Char  operator +  (const char a, const Char &   b) return r(a)
{ r += b.Char::val();  }
inline  Char  operator -  (const char a, const Char &   b) return r(a)
{ r -= b.Char::val();  }
inline  Char  operator *  (const char a, const Char &   b) return r(a)
{ r *= b.Char::val();  }
inline  Char  operator /  (const char a, const Char &   b) return r(a)
{ r /= b.Char::val();  }
inline  Char  operator %  (const char a, const Char &   b) return r(a)
{ r %= b.Char::val();  }
inline  Char  operator << (const char a, const Char &   b) return r(a)
{ r <<= b.Char::val();  }
inline  Char  operator >> (const char a, const Char &   b) return r(a)
{ r >>= b.Char::val();  }
inline  Char  operator &  (const char a, const Char &   b) return r(a)
{ r &= b.Char::val();  }
inline  Char  operator |  (const char a, const Char &   b) return r(a)
{ r |= b.Char::val();  }
inline  Char  operator ^  (const char a, const Char &   b) return r(a)
{ r ^= b.Char::val();  }



inline  char  operator !  (const Char &   a) { return !a.Char::val(); }

inline  char  operator == (const Char &   a, const Char &   b)
{ return a.Char::val() == b.Char::val(); }
inline  char  operator != (const Char &   a, const Char &   b)
{ return a.Char::val() != b.Char::val(); }
inline  char  operator <  (const Char &   a, const Char &   b)
{ return a.Char::val() <  b.Char::val(); }
inline  char  operator <= (const Char &   a, const Char &   b)
{ return a.Char::val() <= b.Char::val(); }
inline  char  operator >  (const Char &   a, const Char &   b)
{ return a.Char::val() >  b.Char::val(); }
inline  char  operator >= (const Char &   a, const Char &   b)
{ return a.Char::val() >= b.Char::val(); }

inline  char  operator == (const Char &   a, const char b)
{ return a.Char::val() == b; }
inline  char  operator != (const Char &   a, const char b)
{ return a.Char::val() != b; }
inline  char  operator <  (const Char &   a, const char b)
{ return a.Char::val() <  b; }
inline  char  operator <= (const Char &   a, const char b)
{ return a.Char::val() <= b; }
inline  char  operator >  (const Char &   a, const char b)
{ return a.Char::val() >  b; }
inline  char  operator >= (const Char &   a, const char b)
{ return a.Char::val() >= b; }

inline  char  operator == (const char a, const Char &   b)
{ return a == b.Char::val(); }
inline  char  operator != (const char a, const Char &   b)
{ return a != b.Char::val(); }
inline  char  operator <  (const char a, const Char &   b)
{ return a <  b.Char::val(); }
inline  char  operator <= (const char a, const Char &   b)
{ return a <= b.Char::val(); }
inline  char  operator >  (const char a, const Char &   b)
{ return a >  b.Char::val(); }
inline  char  operator >= (const char a, const Char &   b)
{ return a >= b.Char::val(); }



//# 27 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2