Bugfixes for slicing and general compile fixes for SymEval component
[dyninst.git] / symEval / rose / SgAsmType.h
1 #if !defined(SG_ASM_TYPE_H)
2 #define SG_ASM_TYPE_H
3
4 #include "SgNode.h"
5 #include "enums.h"
6
7 class SgAsmType : public SgNode {
8  public:
9
10     /*! \brief returns a string representing the class name */
11     virtual std::string class_name() const;
12
13     /*! \brief returns new style SageIII enum values */
14     virtual VariantT variantT() const; // MS: new variant used in tree traversal
15
16     /*! \brief static variant value */
17     static const VariantT static_variant = V_SgAsmType;
18
19     /* the generated cast function */
20     /*! \brief Casts pointer from base class to derived class */
21     friend       SgAsmType* isSgAsmType(       SgNode * s );
22     /*! \brief Casts pointer from base class to derived class (for const pointers) */
23     friend const SgAsmType* isSgAsmType( const SgNode * s );
24
25  public: 
26     virtual ~SgAsmType();
27
28
29  public: 
30     SgAsmType(); 
31
32  protected:
33
34
35 };
36
37 class SgAsmTypeByte : public SgAsmType
38 {
39  public:
40
41     static SgAsmTypeByte* createType();
42
43     /*! \brief returns a string representing the class name */
44     virtual std::string class_name() const;
45
46     /*! \brief returns new style SageIII enum values */
47     virtual VariantT variantT() const; // MS: new variant used in tree traversal
48
49     /*! \brief static variant value */
50     static const VariantT static_variant = V_SgAsmTypeByte;
51
52     /* the generated cast function */
53     /*! \brief Casts pointer from base class to derived class */
54     friend       SgAsmTypeByte* isSgAsmTypeByte(       SgNode * s );
55     /*! \brief Casts pointer from base class to derived class (for const pointers) */
56     friend const SgAsmTypeByte* isSgAsmTypeByte( const SgNode * s );
57
58  public: 
59     virtual ~SgAsmTypeByte();
60
61
62  public: 
63     SgAsmTypeByte(); 
64
65  protected:
66     // Start of memberFunctionString
67     static SgAsmTypeByte* p_builtin_type;
68           
69     // End of memberFunctionString
70
71
72 };
73
74 class SgAsmTypeWord : public SgAsmType
75 {
76  public:
77
78
79     static SgAsmTypeWord* createType();
80
81     /*! \brief returns a string representing the class name */
82     virtual std::string class_name() const;
83
84     /*! \brief returns new style SageIII enum values */
85     virtual VariantT variantT() const; // MS: new variant used in tree traversal
86
87     /*! \brief static variant value */
88     static const VariantT static_variant = V_SgAsmTypeWord;
89
90     /* the generated cast function */
91     /*! \brief Casts pointer from base class to derived class */
92     friend       SgAsmTypeWord* isSgAsmTypeWord(       SgNode * s );
93     /*! \brief Casts pointer from base class to derived class (for const pointers) */
94     friend const SgAsmTypeWord* isSgAsmTypeWord( const SgNode * s );
95
96  public: 
97     virtual ~SgAsmTypeWord();
98
99
100  public: 
101     SgAsmTypeWord(); 
102
103  protected:
104     // Start of memberFunctionString
105     static SgAsmTypeWord* p_builtin_type;
106           
107     // End of memberFunctionString
108
109
110 };
111
112 class SgAsmTypeDoubleWord : public SgAsmType
113 {
114  public:
115
116     static SgAsmTypeDoubleWord* createType();
117
118
119     /*! \brief returns a string representing the class name */
120     virtual std::string class_name() const;
121
122     /*! \brief returns new style SageIII enum values */
123     virtual VariantT variantT() const; // MS: new variant used in tree traversal
124
125     /*! \brief static variant value */
126     static const VariantT static_variant = V_SgAsmTypeDoubleWord;
127
128     /* the generated cast function */
129     /*! \brief Casts pointer from base class to derived class */
130     friend       SgAsmTypeDoubleWord* isSgAsmTypeDoubleWord(       SgNode * s );
131     /*! \brief Casts pointer from base class to derived class (for const pointers) */
132     friend const SgAsmTypeDoubleWord* isSgAsmTypeDoubleWord( const SgNode * s );
133
134  public: 
135     virtual ~SgAsmTypeDoubleWord();
136
137
138  public: 
139     SgAsmTypeDoubleWord(); 
140
141  protected:
142     // Start of memberFunctionString
143     static SgAsmTypeDoubleWord* p_builtin_type;
144           
145     // End of memberFunctionString
146
147
148 };
149
150 class SgAsmTypeQuadWord : public SgAsmType
151 {
152  public:
153
154     static SgAsmTypeQuadWord* createType();
155
156
157     /*! \brief returns a string representing the class name */
158     virtual std::string class_name() const;
159
160     /*! \brief returns new style SageIII enum values */
161     virtual VariantT variantT() const; // MS: new variant used in tree traversal
162
163     /*! \brief static variant value */
164     static const VariantT static_variant = V_SgAsmTypeQuadWord;
165
166     /* the generated cast function */
167     /*! \brief Casts pointer from base class to derived class */
168     friend       SgAsmTypeQuadWord* isSgAsmTypeQuadWord(       SgNode * s );
169     /*! \brief Casts pointer from base class to derived class (for const pointers) */
170     friend const SgAsmTypeQuadWord* isSgAsmTypeQuadWord( const SgNode * s );
171
172  public: 
173     virtual ~SgAsmTypeQuadWord();
174
175
176  public: 
177     SgAsmTypeQuadWord(); 
178
179  protected:
180     // Start of memberFunctionString
181     static SgAsmTypeQuadWord* p_builtin_type;
182           
183     // End of memberFunctionString
184
185
186 };
187
188 class SgAsmTypeDoubleQuadWord : public SgAsmType
189 {
190  public:
191
192
193     static SgAsmTypeDoubleQuadWord* createType();
194     /*! \brief returns a string representing the class name */
195     virtual std::string class_name() const;
196
197     /*! \brief returns new style SageIII enum values */
198     virtual VariantT variantT() const; // MS: new variant used in tree traversal
199
200     /*! \brief static variant value */
201     static const VariantT static_variant = V_SgAsmTypeDoubleQuadWord;
202
203     /* the generated cast function */
204     /*! \brief Casts pointer from base class to derived class */
205     friend       SgAsmTypeDoubleQuadWord* isSgAsmTypeDoubleQuadWord(       SgNode * s );
206     /*! \brief Casts pointer from base class to derived class (for const pointers) */
207     friend const SgAsmTypeDoubleQuadWord* isSgAsmTypeDoubleQuadWord( const SgNode * s );
208
209  public: 
210     virtual ~SgAsmTypeDoubleQuadWord();
211
212
213  public: 
214     SgAsmTypeDoubleQuadWord(); 
215
216  protected:
217     // Start of memberFunctionString
218     static SgAsmTypeDoubleQuadWord* p_builtin_type;
219           
220     // End of memberFunctionString
221
222
223 };
224
225 class SgAsmType80bitFloat : public SgAsmType
226 {
227  public:
228
229     static SgAsmType80bitFloat* createType();
230     /*! \brief returns a string representing the class name */
231     virtual std::string class_name() const;
232
233     /*! \brief returns new style SageIII enum values */
234     virtual VariantT variantT() const; // MS: new variant used in tree traversal
235
236     /*! \brief static variant value */
237     static const VariantT static_variant = V_SgAsmType80bitFloat;
238
239     /* the generated cast function */
240     /*! \brief Casts pointer from base class to derived class */
241     friend       SgAsmType80bitFloat* isSgAsmType80bitFloat(       SgNode * s );
242     /*! \brief Casts pointer from base class to derived class (for const pointers) */
243     friend const SgAsmType80bitFloat* isSgAsmType80bitFloat( const SgNode * s );
244
245  public: 
246     virtual ~SgAsmType80bitFloat();
247
248
249  public: 
250     SgAsmType80bitFloat(); 
251
252  protected:
253     // Start of memberFunctionString
254     static SgAsmType80bitFloat* p_builtin_type;
255           
256     // End of memberFunctionString
257
258
259 };
260
261 class SgAsmType128bitFloat : public SgAsmType
262 {
263  public:
264     static SgAsmType128bitFloat* createType();
265
266
267     /*! \brief returns a string representing the class name */
268     virtual std::string class_name() const;
269
270     /*! \brief returns new style SageIII enum values */
271     virtual VariantT variantT() const; // MS: new variant used in tree traversal
272
273     /*! \brief static variant value */
274     static const VariantT static_variant = V_SgAsmType128bitFloat;
275
276     /* the generated cast function */
277     /*! \brief Casts pointer from base class to derived class */
278     friend       SgAsmType128bitFloat* isSgAsmType128bitFloat(       SgNode * s );
279     /*! \brief Casts pointer from base class to derived class (for const pointers) */
280     friend const SgAsmType128bitFloat* isSgAsmType128bitFloat( const SgNode * s );
281
282  public: 
283     virtual ~SgAsmType128bitFloat();
284
285
286  public: 
287     SgAsmType128bitFloat(); 
288
289  protected:
290     // Start of memberFunctionString
291     static SgAsmType128bitFloat* p_builtin_type;
292           
293     // End of memberFunctionString
294
295
296 };
297
298 class SgAsmTypeSingleFloat : public SgAsmType
299 {
300  public:
301
302
303     static SgAsmTypeSingleFloat* createType();
304     /*! \brief returns a string representing the class name */
305     virtual std::string class_name() const;
306
307     /*! \brief returns new style SageIII enum values */
308     virtual VariantT variantT() const; // MS: new variant used in tree traversal
309
310     /*! \brief static variant value */
311     static const VariantT static_variant = V_SgAsmTypeSingleFloat;
312
313     /* the generated cast function */
314     /*! \brief Casts pointer from base class to derived class */
315     friend       SgAsmTypeSingleFloat* isSgAsmTypeSingleFloat(       SgNode * s );
316     /*! \brief Casts pointer from base class to derived class (for const pointers) */
317     friend const SgAsmTypeSingleFloat* isSgAsmTypeSingleFloat( const SgNode * s );
318
319  public: 
320     virtual ~SgAsmTypeSingleFloat();
321
322
323  public: 
324     SgAsmTypeSingleFloat(); 
325
326  protected:
327     // Start of memberFunctionString
328     static SgAsmTypeSingleFloat* p_builtin_type;
329           
330     // End of memberFunctionString
331
332
333 };
334 class SgAsmTypeDoubleFloat : public SgAsmType
335 {
336  public:
337
338     static SgAsmTypeDoubleFloat* createType();
339     /*! \brief returns a string representing the class name */
340     virtual std::string class_name() const;
341
342     /*! \brief returns new style SageIII enum values */
343     virtual VariantT variantT() const; // MS: new variant used in tree traversal
344
345     /*! \brief static variant value */
346     static const VariantT static_variant = V_SgAsmTypeDoubleFloat;
347
348     /* the generated cast function */
349     /*! \brief Casts pointer from base class to derived class */
350     friend       SgAsmTypeDoubleFloat* isSgAsmTypeDoubleFloat(       SgNode * s );
351     /*! \brief Casts pointer from base class to derived class (for const pointers) */
352     friend const SgAsmTypeDoubleFloat* isSgAsmTypeDoubleFloat( const SgNode * s );
353
354  public: 
355     virtual ~SgAsmTypeDoubleFloat();
356
357
358  public: 
359     SgAsmTypeDoubleFloat(); 
360
361  protected:
362     // Start of memberFunctionString
363     static SgAsmTypeDoubleFloat* p_builtin_type;
364           
365     // End of memberFunctionString
366
367
368 };
369
370 class SgAsmTypeVector : public SgAsmType
371 {
372  public:
373
374     static SgAsmTypeVector* createType(int elementCount, SgAsmType* elementType);
375     /*! \brief returns a string representing the class name */
376     virtual std::string class_name() const;
377
378     /*! \brief returns new style SageIII enum values */
379     virtual VariantT variantT() const; // MS: new variant used in tree traversal
380
381     /*! \brief static variant value */
382     static const VariantT static_variant = V_SgAsmTypeVector;
383
384     /* the generated cast function */
385     /*! \brief Casts pointer from base class to derived class */
386     friend       SgAsmTypeVector* isSgAsmTypeVector(       SgNode * s );
387     /*! \brief Casts pointer from base class to derived class (for const pointers) */
388     friend const SgAsmTypeVector* isSgAsmTypeVector( const SgNode * s );
389
390  public: 
391     int get_elementCount() const;
392     void set_elementCount(int elementCount);
393
394  public: 
395     SgAsmType* get_elementType() const;
396     void set_elementType(SgAsmType* elementType);
397
398
399  public: 
400     virtual ~SgAsmTypeVector();
401
402
403  public: 
404     SgAsmTypeVector(int elementCount = 0, SgAsmType* elementType = NULL); 
405
406  protected:
407     // Start of memberFunctionString
408     int p_elementCount;
409           
410     // End of memberFunctionString
411     // Start of memberFunctionString
412     SgAsmType* p_elementType;
413           
414     // End of memberFunctionString
415 };
416
417 #endif