* auto-profile.c (afdo_annotate_cfg): Use update_max_bb_count.
[official-gcc.git] / gcc / testsuite / g++.old-deja / g++.other / inline12.C
blobc91845c411ee3cad0fa6bc2abed76812048e94ee
1 // { dg-do assemble  }
2 // { dg-options "-O2 -g" }
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>
7 typedef unsigned int    udword;
8 extern "C" {
9 void __assert (const char *, int, const char *);
11 class ShZzy;
12 class ShBe;
13 class Sh
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;
42 class ShZzy : public Sh 
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;
60 class ShBop
62  public:
63   inline ShBop(const ShBe* theBe);
64   void            shWw(bool,
65                                 const char* a1 = "",
66                                 const char* a2 = "",
67                                 int   a3 = -1,
68                                 const char* a4 = "foo");
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;
88 Sh::Sh(const char* theName,
89            const Xy& theXys)
90   :myXys(theXys),
91    myName(theName),
92    myParent(0)
94 const char*
95 Sh::name() const
97   return myName;
99 bool
100 Sh::shXy(const Xy& theXy)
102   return myXys.sh(theXy);
104 ShZzy::ShZzy(const char* theName)
105   :Sh(theName, Xy(0)),
106    iAmInited(false)
108 ShZzy::ShZzy(const char* theName,
109                      const Xy& theXys)
110   :Sh(theName, theXys),
111    iAmInited(false)
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("")
123 ShBop::bopType
124 ShBop::bop()
126   ((!my2 || myBop == shFailed) ? (void)0 : __assert("foo", 91,"foo"));
127   return myBop;
130 ShBop::numberOfVs()
132   return my2 + my1;
134 void
135 ShBop::closeBop()
137   if (myBop == invalidBop)
138   {
139     myBop = shDone;
140   }
142 class ShBe;
143 template <class ShCc>
144 class ShAp : public ShZzy
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;
162 class ShBe : public Sh
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;
179 template <class ShCc> 
180 ShAp<ShCc>::ShAp(const char* theName)
181   : ShZzy(theName),
182     myBop(0),
183     myBe(0)
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)
192 template <class ShCc>
193 ShBop*
194 ShAp<ShCc>::bop()
196   ((myBop) ? (void)0 : __assert("foo", 96,"foo"));
197   return myBop;
199 class xSh : public ShAp<xSh>
201  public:
202   xSh();
203   virtual ~xSh();
204   void ap();
205   void uff();
206   void rtt();
208 class xUff
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;
227 inline
228 xUff::xUff()
229   : myUff(0)
232 inline
233 xUff::xUff(udword theUff)
234   : myUff(theUff)
237 inline
238 xUff::xUff(
239   const xUff& theUff)
240   : myUff(theUff.myUff)
243 inline xUff&
244 xUff::operator = (const xUff& theUff)
246   myUff = theUff.myUff;
247   return *this;
249 inline xUff&
250 xUff::operator = (udword theUff)
252   myUff = theUff;
253   return *this; 
255 inline
256 xUff::operator udword() const
258   return myUff;
260 inline bool
261 xUff::operator < (const xUff ding) const
263   return (((int) (myUff - ding.myUff)) < 0);
265 inline bool
266 xUff::operator <= (const xUff ding) const
268   return (((int) (myUff - ding.myUff)) <= 0);
270 inline bool
271 xUff::operator > (const xUff ding) const
273   return (((int) (myUff - ding.myUff)) > 0);
275 inline bool
276 xUff::operator >= (const xUff ding) const
278   return (((int) (myUff - ding.myUff)) >= 0);
280 inline bool
281 xUff::operator == (const xUff ding) const
283   return (myUff == ding.myUff);
285 inline
286 xUff::xUff(unsigned char* theUff)
288   myUff = *(udword *)theUff;
290 void
291 xSh::uff()
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"));