[thirdparty/gcc.git] / gcc / testsuite / g++.old-deja / g++.other / inline12.C

// { dg-do assemble  }
// { dg-options "-O2 -g" }
// (Should preferrably cycle through options.)
// Origin: Hans-Peter Nilsson <hp@axis.com>
// See <URL:http://gcc.gnu.org/ml/gcc-patches/2000-06/msg00310.html>

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,
                                const char* a1 = "",
                                const char* a2 = "",
                                int   a3 = -1,
                                const 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 ShCc>
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 <class ShCc> 
ShAp<ShCc>::ShAp(const char* theName)
  : ShZzy(theName),
    myBop(0),
    myBe(0)
{}
template <class ShCc> 
ShAp<ShCc>::ShAp(const char* theName,
                                   const Sh::Xy& theXys)
  : ShZzy(theName, theXys),
    myBop(0),
    myBe(0)
{}
template <class ShCc>
ShBop*
ShAp<ShCc>::bop()
{
  ((myBop) ? (void)0 : __assert("foo", 96,"foo"));
  return myBop;
}
class xSh : public ShAp<xSh>
{
 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"));
}
Commit	Line	Data
6481daa9 MM	1	// { dg-do assemble }
6481daa9 MM	2	// { dg-options "-O2 -g" }
adab1923 HPN	3	// (Should preferrably cycle through options.)
	4	// Origin: Hans-Peter Nilsson <hp@axis.com>
	5	// See <URL:http://gcc.gnu.org/ml/gcc-patches/2000-06/msg00310.html>
	6
	7	typedef unsigned int udword;
	8	extern "C" {
	9	void __assert (const char , int, const char );
	10	}
	11	class ShZzy;
	12	class ShBe;
	13	class Sh
	14	{
	15	public:
	16	class Xy;
	17	inline Sh(const char* theName,
	18	const Xy& theXys);
	19	virtual ~Sh();
	20	inline const char* name() const;
	21	inline bool shXy(const Xy& theXy);
	22	virtual void setParent(Sh* theParent);
	23	class Xy
	24	{
	25	public:
	26	Xy(int theXy);
	27	Xy(const Xy& theXy);
	28	Xy& operator = (const Xy&);
	29	bool sh(const Xy& theXy);
	30	private:
	31	int myXyFlags;
	32	};
	33	protected:
	34	Xy myXys;
	35	private:
	36	Sh();
	37	Sh(const Sh&);
	38	Sh& operator = (const Sh&);
	39	const char* myName;
	40	Sh* myParent;
	41	};
	42	class ShZzy : public Sh
	43	{
	44	public:
	45	inline ShZzy(const char* theName);
	46	inline ShZzy(const char* theName,
	47	const Xy& theXys);
	48	virtual ~ShZzy();
	49	void addShTo(char* theParent);
	50	virtual void ap() {}
	51	void addSh(Sh* theSh);
	52	virtual void setParent(Sh* theParent);
	53	void baseAp();
	54	private:
	55	ShZzy();
	56	ShZzy(const ShZzy&);
	57	ShZzy& operator = (const ShZzy&);
	58	bool iAmInited;
	59	};
	60	class ShBop
	61	{
	62	public:
	63	inline ShBop(const ShBe* theBe);
	64	void shWw(bool,
7235a4d4 GDR	65	const char* a1 = "",
7235a4d4 GDR	66	const char* a2 = "",
adab1923	67	int a3 = -1,
7235a4d4	68	const char* a4 = "foo");
adab1923 HPN	69	typedef enum { shOk,
	70	shFailed,
	71	shDone,
	72	invalidBop } bopType;
	73	inline bopType bop();
	74	inline int numberOfVs();
	75	inline void closeBop();
	76	private:
	77	ShBop(const ShBop&);
	78	ShBop& operator = (const ShBop&);
	79	const ShBe* myBe;
	80	bopType myBop;
	81	int my1;
	82	int my2;
	83	const char* my3;
	84	const char* my4;
	85	int my5;
	86	const char* my6;
	87	};
	88	Sh::Sh(const char* theName,
	89	const Xy& theXys)
	90	:myXys(theXys),
	91	myName(theName),
	92	myParent(0)
	93	{}
	94	const char*
	95	Sh::name() const
	96	{
	97	return myName;
	98	}
	99	bool
	100	Sh::shXy(const Xy& theXy)
	101	{
	102	return myXys.sh(theXy);
	103	}
	104	ShZzy::ShZzy(const char* theName)
	105	:Sh(theName, Xy(0)),
	106	iAmInited(false)
	107	{}
	108	ShZzy::ShZzy(const char* theName,
	109	const Xy& theXys)
	110	:Sh(theName, theXys),
	111	iAmInited(false)
	112	{}
	113	ShBop::ShBop(const ShBe* theBe)
	114	:myBe(theBe),
	115	myBop(invalidBop),
	116	my1(0),
	117	my2(0),
	118	my3(""),
	119	my4(""),
	120	my5(0),
	121	my6("")
	122	{}
	123	ShBop::bopType
	124	ShBop::bop()
	125	{
	126	((!my2 \|\| myBop == shFailed) ? (void)0 : __assert("foo", 91,"foo"));
	127	return myBop;
	128	}
	129	int
	130	ShBop::numberOfVs()
	131	{
	132	return my2 + my1;
133	}
134	void
135	ShBop::closeBop()
136	{
137	if (myBop == invalidBop)
138	{
139	myBop = shDone;
140	}
141	}
142	class ShBe;
143	template <class ShCc>
144	class ShAp : public ShZzy
145	{
146	public:
147	ShAp(const char* theName);
148	ShAp(const char* theName,
149	const Xy& theXys);
150	virtual ~ShAp() {}
151	typedef void (ShCc::*ShMethod)();
152	virtual void ap() {}
153	protected:
154	ShBop* bop();
155	private:
156	ShAp();
157	ShAp(const ShAp&);
158	ShAp& operator = (const ShAp&);
159	ShBop* myBop;
160	ShBe* myBe;
161	};
162	class ShBe : public Sh
163	{
164	public:
165	inline ShBe(const char* theName);
166	inline ShBe(const char* theName,
167	const Xy& theXys);
168	inline virtual ~ShBe();
169	virtual void run() = 0;
170	ShBop* runBe();
171	protected:
172	inline ShBop* bop();
173	private:
174	ShBe();
175	ShBe(const ShBe&);
176	ShBe& operator = (const ShBe&);
177	ShBop* myBop;
178	};
179	template <class ShCc>
180	ShAp<ShCc>::ShAp(const char* theName)
181	: ShZzy(theName),
182	myBop(0),
183	myBe(0)
184	{}
185	template <class ShCc>
186	ShAp<ShCc>::ShAp(const char* theName,
187	const Sh::Xy& theXys)
188	: ShZzy(theName, theXys),
189	myBop(0),
190	myBe(0)
191	{}
192	template <class ShCc>
193	ShBop*
194	ShAp<ShCc>::bop()
195	{
196	((myBop) ? (void)0 : __assert("foo", 96,"foo"));
197	return myBop;
198	}
199	class xSh : public ShAp<xSh>
200	{
201	public:
202	xSh();
203	virtual ~xSh();
204	void ap();
205	void uff();
206	void rtt();
207	};
208	class xUff
209	{
210	public:
211	xUff();
212	xUff(const xUff&);
213	xUff& operator = (const xUff&);
214	xUff(udword);
215	operator udword() const;
216	xUff& operator = (udword);
217	bool operator < (const xUff) const;
218	bool operator <= (const xUff) const;
219	bool operator > (const xUff) const;
220	bool operator >= (const xUff) const;
221	bool operator == (const xUff) const;
222	enum {size = 4};
223	xUff(unsigned char* theUff);
224	private:
225	udword myUff;
226	};
227	inline
228	xUff::xUff()
229	: myUff(0)
230	{
231	}
232	inline
233	xUff::xUff(udword theUff)
234	: myUff(theUff)
235	{
236	}
237	inline
238	xUff::xUff(
239	const xUff& theUff)
240	: myUff(theUff.myUff)
241	{
242	}
243	inline xUff&
244	xUff::operator = (const xUff& theUff)
245	{
246	myUff = theUff.myUff;
247	return *this;
248	}
249	inline xUff&
250	xUff::operator = (udword theUff)
251	{
252	myUff = theUff;
253	return *this;
254	}
255	inline
256	xUff::operator udword() const
257	{
258	return myUff;
259	}
260	inline bool
261	xUff::operator < (const xUff ding) const
262	{
263	return (((int) (myUff - ding.myUff)) < 0);
264	}
265	inline bool
266	xUff::operator <= (const xUff ding) const
267	{
268	return (((int) (myUff - ding.myUff)) <= 0);
269	}
270	inline bool
271	xUff::operator > (const xUff ding) const
272	{
273	return (((int) (myUff - ding.myUff)) > 0);
274	}
275	inline bool
276	xUff::operator >= (const xUff ding) const
277	{
278	return (((int) (myUff - ding.myUff)) >= 0);
279	}
280	inline bool
281	xUff::operator == (const xUff ding) const
282	{
283	return (myUff == ding.myUff);
284	}
285	inline
286	xUff::xUff(unsigned char* theUff)
287	{
288	myUff = (udword )theUff;
289	}
290	void
291	xSh::uff()
292	{
293	static const udword halfudword = 0x80000000;
294	xUff aGah((udword)0);
295	udword diagonal = halfudword + (udword) aGah;
296	xUff aGeh(diagonal - 1);
297	xUff aGoh(diagonal + 1);
298	(bop()->shWw ((aGah.operator <=(aGah)), ("foo"), ( ""), 118, "foo"));
299	(bop()->shWw ((aGah.operator >=(aGah)), ("foo"), ( ""), 119, "foo"));
300	(bop()->shWw ((!(aGah.operator <(aGah))), ("foo"), ( ""), 120, "foo"));
301	(bop()->shWw ((!(aGah.operator >(aGah))), ("foo"), ( ""), 121, "foo"));
302	(bop()->shWw ((aGah.operator <(aGeh)), ("foo"), ( ""), 124, "foo"));
303	(bop()->shWw ((aGah.operator <=(aGeh)), ("foo"), ( ""), 125, "foo"));
304	(bop()->shWw ((!(aGah.operator >(aGeh))), ("foo"), ( ""), 126, "foo"));
305	(bop()->shWw ((!(aGah.operator >=(aGeh))), ("foo"), ( ""), 127, "foo"));
306	(bop()->shWw ((aGeh.operator >(aGah)), ("foo"), ( ""), 130, "foo"));
307	(bop()->shWw ((aGeh.operator >=(aGah)), ("foo"), ( ""), 131, "foo"));
308	(bop()->shWw ((!(aGeh.operator <(aGah))), ("foo"), ( ""), 132, "foo"));
309	(bop()->shWw ((!(aGeh.operator <=(aGah))), ("foo"), ( ""), 133, "foo"));
310	(bop()->shWw ((aGeh.operator <(aGoh)), ("foo"), ( ""), 136, "foo"));
311	(bop()->shWw ((aGeh.operator <=(aGoh)), ("foo"), ( ""), 137, "foo"));
312	(bop()->shWw ((!(aGeh.operator >(aGoh))), ("foo"), ( ""), 138, "foo"));
313	(bop()->shWw ((!(aGeh.operator >=(aGoh))), ("foo"), ( ""), 139, "foo"));
314	(bop()->shWw ((aGoh.operator >(aGeh)), ("foo"), ( ""), 142, "foo"));
315	(bop()->shWw ((aGoh.operator >=(aGeh)), ("foo"), ( ""), 143, "foo"));
316	(bop()->shWw ((!(aGoh.operator <(aGeh))), ("foo"), ( ""), 144, "foo"));
317	(bop()->shWw ((!(aGoh.operator <=(aGeh))), ("foo"), ( ""), 145, "foo"));
318	(bop()->shWw ((aGah.operator >(aGoh)), ("foo"), ( ""), 152, "foo"));
319	(bop()->shWw ((aGah.operator >=(aGoh)), ("foo"), ( ""), 153, "foo"));
320	(bop()->shWw ((!(aGah.operator <(aGoh))), ("foo"), ( ""), 154, "foo"));
321	(bop()->shWw ((!(aGah.operator <=(aGoh))), ("foo"), ( ""), 155, "foo"));
322	(bop()->shWw ((aGoh.operator <(aGah)), ("foo"), ( ""), 158, "foo"));
323	(bop()->shWw ((aGoh.operator <=(aGah)), ("foo"), ( ""), 159, "foo"));
324	(bop()->shWw ((!(aGoh.operator >(aGah))), ("foo"), ( ""), 160, "foo"));
325	(bop()->shWw ((!(aGoh.operator >=(aGah))), ("foo"), ( ""), 161, "foo"));
326	}