From: Hans-Peter Nilsson Date: Wed, 14 Jun 2000 19:04:08 +0000 (+0000) Subject: * g++.old-deja/g++.other/inline12.C: New test. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=adab1923788af1d38ca79c91cead991c99f864db;p=gcc.git * g++.old-deja/g++.other/inline12.C: New test. From-SVN: r34554 --- diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 8f5229936cf..64c98bea592 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2000-06-14 Hans-Peter Nilsson + + * g++.old-deja/g++.other/inline12.C: New test. + 2000-06-13 Jakub Jelinek * g++.old-deja/g++.other/eh1.C: New test. diff --git a/gcc/testsuite/g++.old-deja/g++.other/inline12.C b/gcc/testsuite/g++.old-deja/g++.other/inline12.C new file mode 100644 index 00000000000..b853db1090e --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/inline12.C @@ -0,0 +1,326 @@ +// Build don't link: +// Special g++ Options: -O2 -g +// (Should preferrably cycle through options.) +// Origin: Hans-Peter Nilsson +// See + +typedef unsigned int udword; +extern "C" { +void __assert (const char *, int, const char *); +} +class ShZzy; +class ShBe; +class Sh +{ + public: + class Xy; + inline Sh(const char* theName, + const Xy& theXys); + virtual ~Sh(); + inline const char* name() const; + inline bool shXy(const Xy& theXy); + virtual void setParent(Sh* theParent); + class Xy + { + public: + Xy(int theXy); + Xy(const Xy& theXy); + Xy& operator = (const Xy&); + bool sh(const Xy& theXy); + private: + int myXyFlags; + }; + protected: + Xy myXys; + private: + Sh(); + Sh(const Sh&); + Sh& operator = (const Sh&); + const char* myName; + Sh* myParent; +}; +class ShZzy : public Sh +{ + public: + inline ShZzy(const char* theName); + inline ShZzy(const char* theName, + const Xy& theXys); + virtual ~ShZzy(); + void addShTo(char* theParent); + virtual void ap() {} + void addSh(Sh* theSh); + virtual void setParent(Sh* theParent); + void baseAp(); + private: + ShZzy(); + ShZzy(const ShZzy&); + ShZzy& operator = (const ShZzy&); + bool iAmInited; +}; +class ShBop +{ + public: + inline ShBop(const ShBe* theBe); + void shWw(bool, + char* a1 = "", + char* a2 = "", + int a3 = -1, + char* a4 = "foo"); + typedef enum { shOk, + shFailed, + shDone, + invalidBop } bopType; + inline bopType bop(); + inline int numberOfVs(); + inline void closeBop(); + private: + ShBop(const ShBop&); + ShBop& operator = (const ShBop&); + const ShBe* myBe; + bopType myBop; + int my1; + int my2; + const char* my3; + const char* my4; + int my5; + const char* my6; +}; +Sh::Sh(const char* theName, + const Xy& theXys) + :myXys(theXys), + myName(theName), + myParent(0) +{} +const char* +Sh::name() const +{ + return myName; +} +bool +Sh::shXy(const Xy& theXy) +{ + return myXys.sh(theXy); +} +ShZzy::ShZzy(const char* theName) + :Sh(theName, Xy(0)), + iAmInited(false) +{} +ShZzy::ShZzy(const char* theName, + const Xy& theXys) + :Sh(theName, theXys), + iAmInited(false) +{} +ShBop::ShBop(const ShBe* theBe) + :myBe(theBe), + myBop(invalidBop), + my1(0), + my2(0), + my3(""), + my4(""), + my5(0), + my6("") +{} +ShBop::bopType +ShBop::bop() +{ + ((!my2 || myBop == shFailed) ? (void)0 : __assert("foo", 91,"foo")); + return myBop; +} +int +ShBop::numberOfVs() +{ + return my2 + my1; +} +void +ShBop::closeBop() +{ + if (myBop == invalidBop) + { + myBop = shDone; + } +} +class ShBe; +template +class ShAp : public ShZzy +{ + public: + ShAp(const char* theName); + ShAp(const char* theName, + const Xy& theXys); + virtual ~ShAp() {} + typedef void (ShCc::*ShMethod)(); + virtual void ap() {} + protected: + ShBop* bop(); + private: + ShAp(); + ShAp(const ShAp&); + ShAp& operator = (const ShAp&); + ShBop* myBop; + ShBe* myBe; +}; +class ShBe : public Sh +{ + public: + inline ShBe(const char* theName); + inline ShBe(const char* theName, + const Xy& theXys); + inline virtual ~ShBe(); + virtual void run() = 0; + ShBop* runBe(); + protected: + inline ShBop* bop(); + private: + ShBe(); + ShBe(const ShBe&); + ShBe& operator = (const ShBe&); + ShBop* myBop; +}; +template +ShAp::ShAp(const char* theName) + : ShZzy(theName), + myBop(0), + myBe(0) +{} +template +ShAp::ShAp(const char* theName, + const Sh::Xy& theXys) + : ShZzy(theName, theXys), + myBop(0), + myBe(0) +{} +template +ShBop* +ShAp::bop() +{ + ((myBop) ? (void)0 : __assert("foo", 96,"foo")); + return myBop; +} +class xSh : public ShAp +{ + public: + xSh(); + virtual ~xSh(); + void ap(); + void uff(); + void rtt(); +}; +class xUff +{ + public: + xUff(); + xUff(const xUff&); + xUff& operator = (const xUff&); + xUff(udword); + operator udword() const; + xUff& operator = (udword); + bool operator < (const xUff) const; + bool operator <= (const xUff) const; + bool operator > (const xUff) const; + bool operator >= (const xUff) const; + bool operator == (const xUff) const; + enum {size = 4}; + xUff(unsigned char* theUff); + private: + udword myUff; +}; +inline +xUff::xUff() + : myUff(0) +{ +} +inline +xUff::xUff(udword theUff) + : myUff(theUff) +{ +} +inline +xUff::xUff( + const xUff& theUff) + : myUff(theUff.myUff) +{ +} +inline xUff& +xUff::operator = (const xUff& theUff) +{ + myUff = theUff.myUff; + return *this; +} +inline xUff& +xUff::operator = (udword theUff) +{ + myUff = theUff; + return *this; +} +inline +xUff::operator udword() const +{ + return myUff; +} +inline bool +xUff::operator < (const xUff ding) const +{ + return (((int) (myUff - ding.myUff)) < 0); +} +inline bool +xUff::operator <= (const xUff ding) const +{ + return (((int) (myUff - ding.myUff)) <= 0); +} +inline bool +xUff::operator > (const xUff ding) const +{ + return (((int) (myUff - ding.myUff)) > 0); +} +inline bool +xUff::operator >= (const xUff ding) const +{ + return (((int) (myUff - ding.myUff)) >= 0); +} +inline bool +xUff::operator == (const xUff ding) const +{ + return (myUff == ding.myUff); +} +inline +xUff::xUff(unsigned char* theUff) +{ + myUff = *(udword *)theUff; +} +void +xSh::uff() +{ + static const udword halfudword = 0x80000000; + xUff aGah((udword)0); + udword diagonal = halfudword + (udword) aGah; + xUff aGeh(diagonal - 1); + xUff aGoh(diagonal + 1); + (bop()->shWw ((aGah.operator <=(aGah)), ("foo"), ( ""), 118, "foo")); + (bop()->shWw ((aGah.operator >=(aGah)), ("foo"), ( ""), 119, "foo")); + (bop()->shWw ((!(aGah.operator <(aGah))), ("foo"), ( ""), 120, "foo")); + (bop()->shWw ((!(aGah.operator >(aGah))), ("foo"), ( ""), 121, "foo")); + (bop()->shWw ((aGah.operator <(aGeh)), ("foo"), ( ""), 124, "foo")); + (bop()->shWw ((aGah.operator <=(aGeh)), ("foo"), ( ""), 125, "foo")); + (bop()->shWw ((!(aGah.operator >(aGeh))), ("foo"), ( ""), 126, "foo")); + (bop()->shWw ((!(aGah.operator >=(aGeh))), ("foo"), ( ""), 127, "foo")); + (bop()->shWw ((aGeh.operator >(aGah)), ("foo"), ( ""), 130, "foo")); + (bop()->shWw ((aGeh.operator >=(aGah)), ("foo"), ( ""), 131, "foo")); + (bop()->shWw ((!(aGeh.operator <(aGah))), ("foo"), ( ""), 132, "foo")); + (bop()->shWw ((!(aGeh.operator <=(aGah))), ("foo"), ( ""), 133, "foo")); + (bop()->shWw ((aGeh.operator <(aGoh)), ("foo"), ( ""), 136, "foo")); + (bop()->shWw ((aGeh.operator <=(aGoh)), ("foo"), ( ""), 137, "foo")); + (bop()->shWw ((!(aGeh.operator >(aGoh))), ("foo"), ( ""), 138, "foo")); + (bop()->shWw ((!(aGeh.operator >=(aGoh))), ("foo"), ( ""), 139, "foo")); + (bop()->shWw ((aGoh.operator >(aGeh)), ("foo"), ( ""), 142, "foo")); + (bop()->shWw ((aGoh.operator >=(aGeh)), ("foo"), ( ""), 143, "foo")); + (bop()->shWw ((!(aGoh.operator <(aGeh))), ("foo"), ( ""), 144, "foo")); + (bop()->shWw ((!(aGoh.operator <=(aGeh))), ("foo"), ( ""), 145, "foo")); + (bop()->shWw ((aGah.operator >(aGoh)), ("foo"), ( ""), 152, "foo")); + (bop()->shWw ((aGah.operator >=(aGoh)), ("foo"), ( ""), 153, "foo")); + (bop()->shWw ((!(aGah.operator <(aGoh))), ("foo"), ( ""), 154, "foo")); + (bop()->shWw ((!(aGah.operator <=(aGoh))), ("foo"), ( ""), 155, "foo")); + (bop()->shWw ((aGoh.operator <(aGah)), ("foo"), ( ""), 158, "foo")); + (bop()->shWw ((aGoh.operator <=(aGah)), ("foo"), ( ""), 159, "foo")); + (bop()->shWw ((!(aGoh.operator >(aGah))), ("foo"), ( ""), 160, "foo")); + (bop()->shWw ((!(aGoh.operator >=(aGah))), ("foo"), ( ""), 161, "foo")); +}